[Créer une table intermédiaire car elle est plusieurs-à-plusieurs](#Créer une table intermédiaire car elle est plusieurs-à-plusieurs)
[Pensez au modèle en deux (important ici)](# Pensez au modèle en deux)
[(1) Penser du point de vue de l'adepte](# Penser du point de vue de l'adepte)
[② Penser du point de vue du suiveur](# Penser du point de vue du suiveur)
Depuis quelques jours, j'ai eu du mal à comprendre l'association de la fonction de suivi, mais j'ai finalement réussi à la mettre en moi-même, donc je la laisserai comme un mémorandum.
Personnellement, je me suis trompé au niveau de la ** description de l'association au modèle User **, donc j'écris principalement à ce sujet. Donc cette fois, je n'ai pas abordé l'implémentation de la vue et du contrôleur.
Je vais donc commencer immédiatement.
Étant donné que l'association de fonction suivante est une association plusieurs-à-plusieurs (d'utilisateur à utilisateur), Il est nécessaire de préparer une table intermédiaire et d'en faire une association "un-à-plusieurs" (utilisateur à relations).
(Pour ceux qui aiment un-à-plusieurs ou plusieurs-à-plusieurs, [[pour les débutants] tutoriel d'association de Rails qui est trop poli [quoi que ce soit] [parfaitement compris]](https://qiita.com/kazukimatsumoto/items/14bdff681ec5ddac26d1 #% E3% 83% 95% E3% 82% A9% E3% 83% AD% E3% 83% BC% E3% 83% 95% E3% 82% A9% E3% 83% AD% E3% 83% AF% E3% 83% BC% E6% A9% 9F% E8% 83% BD% E3% 82% 92er% E5% 9B% B3% E3% 82% 92% E4% BD% BF% E3% 81% A3% E3% 81% A6% E8% A8% AD% E8% A8% 88% E3% 81% 97% E3% 82% 88% E3% 81% 86) Je recommande l'article. J'ai appris.)
Alors tout d'abord, créez un modèle de relation.
$ rails g model Relationship
Ajoutez following_id (id côté suivant) et follower_id (id côté suivant) au fichier de migration.
202008111333110_create_relationships.rb
class CreateRelationships < ActiveRecord::Migration[5.2]
def change
create_table :relationships do |t|
#Disciple
t.integer :following_id
#Côté suivi
t.integer :follower_id
t.timestamps null: false
end
add_index :relationships, :following_id
add_index :relationships, :follower_id
add_index :relationships, [:following_id, :follower_id], unique: true
end
end
N'oubliez pas ...
$ rails db:migrate
D'ici ** ① En regardant le suiveur ** ** ② En regardant le côté à suivre ** Il est nécessaire de faire la distinction entre les deux. Attention, vous ne saurez pas ce que c'est si vous le rendez ambigu!
Tout d'abord ... ** 1. Pensez au modèle de relation en deux parties ** ・ Active_relationships (en regardant le suiveur) ・ Passive_relationships (du point de vue de la personne suivie)
user.rb
class User < ApplicationRecord
has_many :active_relationships, class_name: "Relationship", foreign_key: :following_id, dependent: :destroy
has_many :passive_relationships, class_name: "Relationship", foreign_key: :follower_id, dependent: :destroy
end
Puisqu'il s'agit simplement de "supposer" qu'un modèle de relation reçoit un nom et est divisé en deux modèles, il est nécessaire de décrire dans nom_classe qu'il s'agit en réalité d'un modèle de relation.
De plus, du point de vue du suiveur, le suiveur (follower_id) est extrait en fonction du suiveur (suivant_id), il est donc nécessaire de spécifier le primary_key (clé externe) comme suit_id.
Au contraire, du point de vue du côté suiveur, le côté suiveur (following_id) est tiré en fonction du côté suiveur (follower_id), il est donc nécessaire de spécifier le primary_key (clé externe) comme follower_id.
** 2. Pensez au modèle User en deux parties ** ・ Suivant (regardant le côté à suivre) ・ Follower (la ligne de mire de l'adepte)
relationship.rb
class Relationship < ApplicationRecord
belongs_to :following, class_name: "User"
belongs_to :follower, class_name: "User"
end
Comme pour le modèle de relation, il s'agit simplement de "supposer" qu'un modèle utilisateur reçoit un nom et est divisé en deux modèles, il est donc nécessaire de décrire dans nom_classe qu'il s'agit vraiment d'un modèle utilisateur.
1ère ligne: ** Décrivez le modèle des relations (active_relationships car c'est le côté à suivre ici) ** Il a déjà été expliqué où le modèle de relations ci-dessus est divisé en deux.
Ligne 2: ** Rassemblez les personnes suivies via active_relationship ** Rassemblez les personnes suivies par active_relationships. Pour collecter les personnes qui sont suivies, vous vous référerez au modèle "suiveur", alors écrivez source :: suiveur. Puisque nous avons nommé cette série de flux «suivis», nous la décrivons comme has_many: followings.
user.rb
has_many :active_relationships, class_name: "Relationship", foreign_key: :following_id
has_many :followings, through: :active_relationships, source: :follower
Ligne 1: ** Tout d'abord, décrivez le modèle de relations (passives_relationships ici) ** Il a déjà été expliqué où le modèle de relations ci-dessus est divisé en deux.
Ligne 2: ** Rassemblez les personnes que vous suivez via passive_relationship ** Rassemblez les personnes suivies par des relations passives. Pour collecter les personnes qui sont suivies, vous vous référerez au modèle "suivant", alors écrivez source :: following. Puisque nous avons nommé cette série de flux "followers", nous la décrivons comme has_many: followers.
user.rb
has_many :passive_relationships, class_name: "Relationship", foreign_key: :follower_id
has_many :followers, through: :passive_relationships, source: :following
La description finale du modèle utilisateur est donc la suivante.
user.rb
class User < ApplicationRecord
#La ligne de mire de l'adepte
has_many :active_relationships, class_name: "Relationship", foreign_key: :following_id
has_many :followings, through: :active_relationships, source: :follower
#Regardant le côté à suivre
has_many :passive_relationships, class_name: "Relationship", foreign_key: :follower_id
has_many :followers, through: :passive_relationships, source: :following
end
C'est la fin.
Afin de terminer la fonction suivante, il est nécessaire d'implémenter la vue et le contrôleur séparément.
Cela dit, j'ai en fait expérimenté et ressenti que la montagne d'implémentation de la fonction de suivi réside dans la "compréhension de la description du modèle User", donc je pense que si vous traversez cette montagne, vous pouvez l'implémenter sans difficulté. : pouces vers le haut:
Je pense que le point cette fois est de ** diviser un modèle en deux **.
En premier lieu, la structure selon laquelle l'adepte et l'adepte font référence à un modèle appelé modèle utilisateur et apportent les données est compliquée, il semble donc s'agir de la relation entre le modèle Post de la fonction similaire et le modèle utilisateur. De plus, si vous supposez que le modèle User est composé de deux modèles (bien qu'il s'agisse en fait d'un modèle) et que vous organisez les relations, je pense que vous pouvez penser qu'il peut s'agir d'une histoire étonnamment simple.
Merci d'avoir lu jusqu'ici. Je suis un débutant qui n'a pas encore assez de connaissances, alors j'apprécierais que vous me donniez quelques conseils en cas de problème.
Recommended Posts