[RUBY] [Rails] Ich werde die Prozedur zum Implementieren der Follow-Funktion mit form_with erklären.
Überblick
Ich werde die Prozedur schreiben, um die folgende Funktion mit form_with zu implementieren!
Wir werden die folgenden Funktionen implementieren __1. Fähigkeit, Benutzern zu folgen / zu folgen __ __2. Befolgen Sie die Anzeigefunktion für Benutzer- / Follower-Listen __
Ich habe auf den Artikel So erstellen Sie eine Follow-Funktion mit Rails verwiesen, und insbesondere für eine ausführliche Erläuterung der Zuordnung zur Follow-Funktion ist dieser Artikel sehr hilfreich. wurde!
Annahme
Umgebung ・ Schienen 5.2.4.2 ・ Ruby 2.6.5 ・ Schlank · Entwickeln
__ Außerdem wird davon ausgegangen, dass Benutzerfunktionen implementiert sind. __ __
__ So richten Sie eine Rails-Anwendung in der oben genannten Umgebung ein __
__ ↓ Nach der Implementierung sieht es so aus. (Es tut mir leid, es sieht einfach aus ...) ↓ __
Implementierung der Follow / Unfollow-Funktion
1. Erstellung eines Beziehungsmodells
$ rails g model Relationship user:references follow:references
__ · Die hier erstellte "Beziehungstabelle" ist eine Zwischentabelle, der die Benutzer und die Benutzer folgen müssen. __ __
__ · Lassen Sie die Zwischentabelle "Benutzer" als Follower-Benutzermodell und "Folgen" als Follower-Benutzermodell erkennen. __ __
2. Bearbeiten Sie die Migrationsdatei für Beziehungen
db/migrate/[timestamps]_create_relationships.rb
class CreateRelationships < ActiveRecord::Migration[5.2]
def change
create_table :relationships do |t|
t.references :user, foreign_key: true
t.references :follow, foreign_key: { to_table: :users }
t.timestamps
t.index [:user_id, :follow_id], unique: true
end
end
end
Der Grund, warum die referenzierten Modelle durch __ · Benutzer und Folgen getrennt werden, besteht darin, dass der "folgende Benutzer" und der "folgende Benutzer" als separate Modelle betrachtet werden müssen. __ __
__ · t.references: user, Foreign_key: true__: __user Der externe Schlüssel für das Modell wird festgelegt. __ __
__ · t.references: follow, Foreign_key: {to_table :: users} __: __follow Der externe Schlüssel für das Modell wird festgelegt. Das folgende Modell ist ein fiktiver Modellname, der nicht existiert, und ich erstelle ihn derzeit. Durch Setzen von {to_table :: users} wird daher das Modell der Referenzquelle gelernt. __ __
__ ・ t.index [: user_id ,: follow_id], unique: true__: Durch die Eindeutigkeit der Kombination von __user_id und follow_id wird die Duplizierung von Daten verhindert, dh, derselbe Benutzer wird zweimal verfolgt. Wird verhindert. __ __
3. Speichern Sie den Inhalt der DB
$ rails db:migrate
4. Beschreiben Sie die Zuordnung für Benutzer im Beziehungsmodell.
app/models/relationship.rb
class Relationship < ApplicationRecord
belongs_to :user
belongs_to :follow, class_name: "User"
validates :user_id, presence: true
validates :follow_id, presence: true
end
__ · gehört_zu: Benutzer__: __ Dies ist die übliche Zuordnung. __ __
__ · gehört zu: follow, Klassenname:" Benutzer " __: __ Es wird beschrieben, dass es der Klasse follow gehört, aber wie oben erwähnt, ist follow eine fiktive Klasse, also beziehen Sie sich auf sie mit class_name:" User " Ich werde Ihnen das Originalmodell erzählen. __ __
5. Beschreiben Sie die Zuordnung für die Beziehung in der Benutzermodelldatei.
app/models/user.rb
class User < ApplicationRecord
#==============Zuordnung zu Benutzern, denen ein Benutzer folgt=================
has_many :relationships, foreign_key: "user_id",
dependent: :destroy
has_many :followings, through: :relationships, source: :follow
#==========================================================================
#==============Zuordnung zu Benutzern, die einem Benutzer folgen================
has_many :passive_relationships, class_name: "Relationship",
foreign_key: "follow_id",
dependent: :destroy
has_many :followers, through: :passive_relationships, source: :user
#===========================================================================
end
__ · Die obige Beziehungsmodelldatei beschreibt "Assoziationen für einen Benutzer, um auf einen Benutzer zuzugreifen, dem gefolgt wird" und "Assoziationen für einen Benutzer, um auf einen Benutzer zuzugreifen, dem gefolgt wird". Mit anderen Worten werden die Details später in der Figur beschrieben. __ __
5-1. Lassen Sie uns zunächst über die Zuordnung zu dem Benutzer sprechen, dem ein Benutzer folgt!
__ · has_many: Relationships, Foreign_key:" user_id ", abhängige :: destroy__: __ Dies deklariert eine Zuordnung`, mit der ein Benutzer auf den externen Schlüssel user_id der Zwischentabellenbeziehungen zugreifen kann. Ich bin. __ __
__ Ich denke, es ist leicht zu verstehen, wenn Sie es sich wie folgt vorstellen! __ __
__ · has_many :folgen, durch :: Beziehungen, Quelle :: folgen__: __ Dies deklariert eine Zuordnung, die es einem Benutzer ermöglicht, über die follow_id der Zwischentabellenbeziehungen auf das folgende Modell zuzugreifen. Ich werde. __ __
__ Das Bild sieht so aus! __ __
__ ・ In den beiden obigen Zeilen können Sie die Benutzer abrufen, denen der Benutzer folgt, indem Sie "User.followings" festlegen. Sobald dies verfügbar ist, können Sie einfach eine Liste der Follower eines bestimmten Benutzers anzeigen. __ __
5-2 Als nächstes folgt die Erklärung der Zuordnung zu dem Benutzer, der einem bestimmten Benutzer folgt!
__ · has_many: passive_relationships, class_name:" Relationship ", Foreign_key:" follow_id ", abhängige :: destroy__: __ Dies deklariert eine Zuordnung, die es einem Benutzer ermöglicht, auf die follow_id von passiven_relationships zuzugreifen. Ich bin.
Da passive_relationships ein fiktives Modell ist, das ich selbst erstellt habe, unterrichte ich das Referrer-Modell als Klassenname: "Beziehung". __ __
Das Bild ist wie folgt!
__ · has_many: Follower über :: passive_relationships, source :: user__: __ Dies deklariert eine Zuordnung, die es einem Benutzer ermöglicht, über die user_id von passive_relationships auf Follower zuzugreifen. __ __
Das Bild ist wie folgt!
__ ・ Wenn Sie in den beiden obigen Zeilen User.followers verwenden, können Sie die Benutzer ermitteln, die User folgen. Mit dieser Funktion können Sie ganz einfach eine Liste der Benutzer anzeigen, die einem bestimmten Benutzer folgen! __ __
6. Definieren Sie folgende Instanzmethoden in der Benutzermodelldatei
app/models/user.rb
class User < ApplicationRecord
.
.
.
#<Assoziationsbezogene Beschreibung weggelassen>
.
.
.
def following?(other_user)
self.followings.include?(other_user)
end
def follow(other_user)
unless self == other_user
self.relationships.find_or_create_by(follow_id: other_user.id)
end
end
def unfollow(other_user)
relationship = self.relationships.find_by(follow_id: other_user.id)
relationship.destroy if relationship
end
end
-
Überprüfen Sie, ob der Benutzer @user folgt, indem Sie
following? (Other_user): __User.followings.include? (@User)festlegen. Bei der Implementierung der Schaltfläche "Folgen" wird bedingt verzweigt, ob die Schaltfläche zum Folgen oder die Schaltfläche zum Entfolgen angezeigt werden soll. __ __ -
Durch Einstellen von
follow (other_user): __User.follow (@user)können Sie @user folgen.es sei denn self == other_userhindert dich daran, dir selbst zu folgen. Ich verwende find_or_create_by, um auf den ID-Datensatz von @user zu verweisen, falls vorhanden, und um ihn zu erstellen, wenn er nicht vorhanden ist. __ __ -
Durch Einstellen von
unfollow (other_user): __User.unfollow (@user)können Sie @user entfolgen. __ __ -
Da wir die Methode definiert haben, die folgt, um dem __user zu folgen und ihn zu entfolgen, besteht der nächste Schritt darin, einen Beziehungscontroller zu erstellen und die Funktion zu implementieren, um tatsächlich auf die Datenbank zuzugreifen und mit diesen Methoden zu folgen / nicht zu folgen. Ich werde das machen! __ __
7. Erstellen Sie einen Beziehungscontroller.
$ rails g controller relationships
app/controllers/relationships_controller.rb
class RelationshipsController < ApplicationController
before_action :set_user
def create
following = current_user.follow(@user)
if following.save
flash[:success] = "Dem Benutzer gefolgt"
redirect_to @user
else
flash.now[:alert] = "Benutzer konnte nicht verfolgt werden"
redirect_to @user
end
end
def destroy
following = current_user.unfollow(@user)
if following.destroy
flash[:success] = "Nicht folgender Benutzer"
redirect_to @user
else
flash.now[:alert] = "Benutzer konnte nicht entfolgt werden"
redirect_to @user
end
end
private
def set_user
@user = User.find(params[:relationship][:follow_id])
end
end
- Im __relationships-Controller funktionieren nur die Erstellungsaktion, die dem Benutzer folgt, und die Zerstörungsaktion, die nicht folgt. Schreiben Sie daher nur die Erstellungsaktion und die Zerstörungsaktion. __ __ -Für das __` Follow / Unfollow-Button-Formular werden Daten in Form von Parametern [: Beziehung] [: Follow_ID] gesendet, sodass die Daten in Form von Suchen (Parameter [: Beziehungen] [: Follow_ID]) vorliegen. Bekommen. __ __
-__ Before_action: set_user__: __ Da @user immer in jeder Aktion erfasst wird, wird die private Methode set_user definiert und dann before_action verwendet, um sie im Voraus zu erfassen. __ __
-__ Aktion erstellen __: __ Der angemeldete Benutzer (aktueller_Benutzer) folgt dem erfassten @Benutzer. Ich verwende die in der Benutzermodelldatei definierte Instanzmethode follow (other_user). __ __
· __ Zerstörung Aktion __: __ Der angemeldete Benutzer folgt dem erfassten Benutzer nicht mehr. Ich verwende die in der Benutzermodelldatei definierte Instanzmethode unfollow (other_user). __ __
・ __ Da die Funktion zum tatsächlichen Zugriff auf die Datenbank und zum Verfolgen / Entfolgen abgeschlossen ist, besteht der nächste Schritt darin, die Schaltfläche zum tatsächlichen Verfolgen / Entfolgen zu implementieren! __ __
8. Implementieren Sie die Schaltfläche Folgen / Entfolgen mit form_with.
__ ・ Erstellen Sie zunächst eine Datei functions / _follow_form.html.slim im Verzeichnis app / views. __ __
ruby:app/views/relationships/_follow_form.html.slim
- unless current_user == user
#Schaltfläche nicht mehr folgen
- if current_user.following?(user)
= form_with model: @relationship, url: relationship_path, method: :delete, local: true do |f|
= f.hidden_field :follow_id, value: user.id
= f.submit "Nicht mehr folgen"
#Folgen Schaltfläche
- else
= form_with model: @set_relationship, url: relationships_path, local: true do |f|
= f.hidden_field :follow_id, value: user.id
= f.submit "Folgen"
__ · -unless current_user == user__: __ Die Anzeige der Schaltfläche selbst ist so geschaltet, dass Sie sich selbst nicht folgen können. Der Benutzer bezieht sich hier auf den @user, den die Ansicht erhält, die diesen Teil platziert. __ __
8-1. Erklärung der Schaltfläche zum Entfolgen
__ · -if current_user.following? (User) __: __ Überprüfen, ob der angemeldete Benutzer dem anderen Benutzer folgt. Wenn Sie folgen, wird die Schaltfläche "Nicht folgen" angezeigt. Wenn Sie nicht folgen, wird die Schaltfläche "Folgen" angezeigt. __ __
・= form_with model: @relationship, url: relationship_path, method: :delete, local: true do |f|：Dies ist eine Schaltfläche zum Entfolgen.
__model: @ ratio @relationship ist eine Instanzvariable, die die Beziehung zwischen dem angemeldeten Benutzer und dem anderen Benutzer abruft. __ __
__ (Wenn Sie dieses Formular für die Schaltfläche "Folgen" in app / views / users / show.html.slim platzieren, definieren Sie die Instanzvariable @relationship in der Aktion show der Datei app / controller / users_controller.rb.) __ __
__url: Relationship_path ist das Routing zur Zerstörungsaktion des Relationship Controllers. Wir werden das Routing später beschreiben. __ __
__method :: delete gibt die DELETE-Methode in der HTTP-Anforderung an. __ __
Wenn __local: true nicht hinzugefügt wird, lautet die Formularübermittlungsspezifikation Ajax, und Daten können nicht übermittelt werden. Beschreiben Sie sie daher unbedingt in form_with. __ __
__ ・ f.hidden_field: follow_id, value: user.id__: Dieser Teil ist leicht zu verstehen, wenn Sie sich den fertigen Quellcode ansehen. __ __
Durch Angabe von> __: follow_id werden Daten in Form von Parametern [: Beziehung] [: follow_id] gesendet. Der von der privaten Methode set_user des Relationship Controllers definierte Teil empfängt diese Daten. __ __
Durch Angabe von> __value: user.id wird die ID des anderen Benutzers, der folgt, in: follow_id gespeichert und die Daten werden gesendet. __ __
8-2. Folgen Sie der Taste
・= form_with model: @set_relationship, url: relationships_path, local: true do |f|：Dies ist ein Formular, um dem anderen Benutzer zu folgen.
Die Instanzvariable @set_relationship von model: @ set_relationship generiert ein leeres Modell, und die Daten werden in Form von Parametern [: Beziehung] [: follow_id] unter Bezugnahme auf dieses leere Modell gesendet. Um das zu tun.
__url: Relationship_path ist das Routing zur Erstellungsaktion des Relationship Controllers. Wir werden das Routing später beschreiben. __ __
__ ・ = f.hidden_field: follow_id, value: user.id: Überprüfen wir den tatsächlich abgeschlossenen Quellcode. __ __
__ Wie bei der Schaltfläche "Nicht folgen" werden die Daten in Form von Parametern [: Beziehung] [: follow_id] gesendet. __ __
__ ・ Nachdem die Schaltfläche "Folgen / Entfolgen" erstellt wurde, ist es an der Zeit, das Routing so einzustellen, dass diese Daten normal an die Aktion gesendet werden! __ __
9. Fügen Sie dem Relationship Controller Routing hinzu.
config/routes.rb
Rails.application.routes.draw do
.
.
#<Anderes Routing entfällt>
.
.
resources :relationships, only: [:create, :destroy]
Überprüfen Sie die hinzugefügten Routen mit dem Befehl __ · $ Rails Routen | Grep-Beziehung. __ __
$ rails routes | grep relationship
relationships POST /relationships(.:format) relationships#create
relationship DELETE /relationships/:id(.:format) relationships#destroy
__ ・ Sie können jetzt bestätigen, dass Sie mit "Beziehungspfad" folgen / mit "Beziehungspfad" nicht mehr folgen können. __ __
10. Platzieren Sie eine Schaltfläche zum Folgen / Entfolgen.
__ ・ Ich möchte es in die Datei app / views / users / show.html.slim einfügen, falls Sie folgen oder nicht folgen möchten, wenn Sie zur Seite des anderen Benutzers springen. __ __
ruby:app/views/users/show.html.slim
h1 Benutzerprofilseite
p
= "Name: "
= @user.username
#================Schaltfläche "Folgen" hinzufügen=============================
= render 'relationships/follow_form', user: @user
#============================================================
p= link_to "Profil bearbeiten", edit_user_path(current_user)
__ · Benutzer: @user__: __ Der im Teil beschriebene Benutzer bezieht sich auf den in der Aktion show definierten @user. __ __
__- Die Schaltfläche wurde platziert, aber die Schaltfläche funktioniert nicht so wie sie ist. Dies liegt daran, dass, wie bereits erwähnt, die Instanzvariable @relationship und die Instanzvariable @set_relationship in der Aktion show definiert werden müssen. __ __
11.app/controllers/users_controller.rbのshowアクションに、インスタンス変数を定義する。
app/controllers/users_controller.rb
class UsersController < ApplicationController
.
.
.
def show
@user = User.find(params[:id])
@relationship = current_user.relationships.find_by(follow_id: @user.id)
@set_relationship = current_user.relationships.new
end
.
.
.
end
__ · @ ratio = current_user.relationships.find_by (follow_id: @ user.id) __: __ Dies ist die Instanzvariable, auf die in der nicht folgenden Form verwiesen wird. Wenn Sie hier die Beziehungen zwischen current_user und @user abrufen, können Sie Daten wie params [: Relationship] [: follow_id] in der Form senden. __ __
__ · @ set_relationship = current_user.relationships.new __: __ Dies ist die Instanzvariable, auf die im folgenden Formular verwiesen wird. Ich möchte Daten in Form von Parametern [: Beziehung] [: follow_id] senden, also erstelle ich eine leere Instanzvariable wie diese. __ __
__ ・ Damit ist die Implementierung der Funktion zum Folgen / Entfolgen von Benutzern abgeschlossen! Als nächstes implementieren wir eine Funktion, um eine Liste der Benutzer anzuzeigen, die uns folgen / Benutzer, die uns folgen! __ __
Befolgen Sie die Anzeigefunktion für Benutzer- / Follower-Listen
1. Erstellen Sie zunächst einen Link zur folgenden Seite der Benutzer- / Follower-Liste in der Ansicht.
__ · Fügen Sie einen Link zur Follower- / Follower-Listenseite des Benutzers in app / views / users / show.html.slim hinzu. __ __
ruby:app/views/users/show.html.slim
h1 Benutzerprofilseite
p
= "Name: "
= @user.username
#==============Link zur Follow / Follower-Listenseite=================
= link_to "Folgen: #{@user.followings.count}", followings_user_path(@user.id)
= "／"
= link_to "Anhänger: #{@user.followers.count}", followers_user_path(@user.id)
#============================================================
= render 'relationships/follow_form', user: @user
p= link_to "Profil bearbeiten", edit_user_path(current_user)
__ · Um auf Follower / Follower zuzugreifen, verwenden Sie die zuvor in der Benutzermodelldatei definierten Follower / Follower. __ __
__ · @ user.followings.count __: __ Zeigt die Anzahl der Benutzer an, denen der Benutzer folgt. __ __
__ · followings_user_path (@ user.id) __: __ Ich möchte den Pfad angeben, in dem die URL users /: id / Following lautet. Schreiben Sie also wie links gezeigt. Ich werde das Routing später schreiben, damit Sie diesen Pfadtyp angeben können. __ __
__ ・ Der Zugriff auf die Follower-Listenseite wird genauso beschrieben wie der Zugriff auf die folgende Benutzerlistenseite. __ __
2. Fügen Sie der Seite Follow / Follower List eine Route hinzu.
config/routes.rb
Rails.application.routes.draw do
.
.
.
resources :users do
get :followings, on: :member
get :followers, on: :member
end
.
.
.
end
__ ・ Überprüfen Sie nach dem Schreiben wie oben das Routing mit dem Befehl $ Rails Routen | grep follow. __ __
$ rails routes | grep follow
followings_user GET /users/:id/followings(.:format) users#followings
followers_user GET /users/:id/followers(.:format) users#followers
__ ・ followings_user_path springt zur Seite der folgenden Benutzerliste und follers_user_path springt zur Seite der Follower-Liste, dies ist also in Ordnung. __ __
__ · Da sowohl die folgende Aktion als auch die folgende Aktion in der Benutzerressource verschachtelt sind, definieren Sie zwei Aktionen im Benutzercontroller. __ __
3. Fügen Sie dem Benutzer-Controller die folgenden Aktionen und Follower-Aktionen hinzu.
app/controllers/users_controller.rb
class UsersController < ApplicationController
.
.
.
def followings
@user = User.find(params[:id])
@users = @user.followings.all
end
def followers
@user = User.find(params[:id])
@users = @user.followers.all
end
.
.
.
__ · In der folgenden Aktion werden alle Benutzer erfasst, denen @user folgt, und in der Follower-Aktion werden alle Follower von @user erfasst. __ __
4. Erstellen Sie eine Ansicht, in der eine Liste der Follower / Follower angezeigt wird.
__ · Erstellen Sie die Dateien followings.html.slim und follers.html.slim im Verzeichnis app / views / users. __ __
ruby:app/views/users/followings.html.slim
h2 Anhänger
- @users.each do |user|
hr
= "username: "
= link_to user.username, user_path(user.id)
ruby:app/views/users/followers.html.slim
h2 Anhänger
- @users.each do |user|
hr
= "username: "
= link_to user.username, user_path(user.id)
__ ・ Damit ist die Erstellung der Seite Follow User / Follow User List abgeschlossen! __ __
Artikel, die ich als Referenz verwendet habe
So erstellen Sie eine Follow-Funktion mit Rails
Recommended Posts