Rails has_many :par le biais de recherche par Attributs Supplémentaires dans la Jointure Modèle

Nouveau à Ruby et Rails, mais je suis livre instruits par maintenant (qui, apparemment, ne veut rien dire, haha).

J'en ai deux modèles, l'Événement et l'Utilisateur rejoint par le biais d'un tableau EventUser

class User < ActiveRecord::Base
  has_many :event_users
  has_many :events, :through => :event_users
end

class EventUser < ActiveRecord::Base
  belongs_to :event
  belongs_to :user

  #For clarity's sake, EventUser also has a boolean column "active", among others
end

class Event < ActiveRecord::Base
  has_many :event_users
  has_many :users, :through => :event_users
end

Ce projet est un calendrier, dans lequel je dois garder la trace de gens de la signature et de rayer leur nom pour un événement donné. Je me figure la nombreux de nombreux est une bonne approche, mais je ne peux pas faire quelque chose comme ceci:

u = User.find :first
active_events = u.events.find_by_active(true)

Parce que les événements n'ONT pas réellement de données supplémentaires, le EventUser modèle ne. Et alors que je pouvais faire:

u = User.find :first
active_events = []
u.event_users.find_by_active(true).do |eu|
  active_events << eu.event
end

Cela semble être contraire à "les rails de chemin". Quelqu'un peut m'éclairer, ce qui a été m'énerve pour un long temps ce soir (ce matin)?

Vous pouvez également créer un nom de champ à l'aide de Gareth de la suggestion.

InformationsquelleAutor Stefan Mai | 2009-01-03

123

Comment sur l'ajout de quelque chose comme cela dans votre modèle d'Utilisateur?
```
has_many  :active_events, :through => :event_users, 
          :class_name => "Event", 
          :source => :event, 
          :conditions => ['event_users.active = ?',true]
```
Après cela, vous devriez être en mesure d'obtenir événements actifs pour un utilisateur simplement en appelant le:
```
User.first.active_events
```
- La belle, qui va faire de grands.
- Je vous ai marqué, mais si je n'ai pas une meilleure réponse au matin, c'est la vôtre.
- ok. Je suis en Europe, je vais donc attendre jusqu'au coucher du soleil 😉
- Voir ma réponse ci-dessous pour une plus up-to-date mode
- Merci, Rails de la voie 4 est: -> { where event_users: { active: true } }
- Mais il n'y a aucune chance que la condition est définie par un event_users portée? Comme scope :active, where(:active => true)? (à l'aide de Rails 3.2)
- pourriez-vous expliquer d'où cela pourrait être compatible avec has_many through:? Pourriez-vous inclure l'ensemble de Rails 4 équivalent en particulier?
- au lieu de :conditions. version complète
- Cheers @IvanBlack.
InformationsquelleAutor Milan Novota
22

Milan Novota a une bonne solution, mais :conditions est maintenant obsolète et la :conditions => ['event_users.active = ?',true] peu juste ne semble pas très rails de toute façon. Je préfère quelque chose comme ceci:
```
has_many :event_users
has_many :active_event_users, -> { where active: true }, class_name: 'EventUser'
has_many :active_events, :through => :active_event_users, class_name: 'Event', :source => :event
```
Après que vous devriez toujours être en mesure d'obtenir événements actifs pour un utilisateur simplement en appelant le:
```
User.first.active_events
```
- Si vous n'êtes pas encore sur les Rails 4, vous pouvez toujours suivre ce bel exemple, mais vous pouvez avoir besoin d'utiliser le obsolète :conditions => {active: true}. A fonctionné pour moi, merci!
InformationsquelleAutor msanteler
12

Même si votre u.les événements n'est pas explicitement l'appel de la user_events table, la table est toujours inclus dans le SQL implicitement parce que les jointures nécessaires. Donc, vous pouvez toujours utiliser cette table dans votre conditions de la recherche:
```
u.events.find(:all, :conditions => ["user_events.active = ?", true])
```
Bien sûr, si vous prévoyez de faire cette recherche beaucoup, alors assurez-vous, donnez-lui une association indépendante de Milan Novota suggère, mais il n'y a pas exigence pour vous de le faire de cette façon
- J'aime définir tous les champs d'application à une place - dans le modèle, même si je les utiliser une seule fois. Il garde mon contrôleurs mince et la conception globale plus cohérente.
- Certainement bon à savoir, merci de Gareth.
InformationsquelleAutor Gareth

Bien, plus la responsabilité est en cours de mise en User modèle que nécessaire, et il n'y a pas de bonne raison de le faire.

On peut d'abord définir le champ d'application dans EventUser modèle parce que là où il appartient, comme:

class EventUser < ActiveRecord::Base
  belongs_to :event
  belongs_to :user

  scope :active,   -> { where(active: true)  }
  scope :inactive, -> { where(active: false) } 
end

Maintenant, un utilisateur pourrait avoir les deux types d'événements: événements actifs ainsi que les événements inactifs, nous pouvons donc définir la relation en User modèle comme suit:

class User < ActiveRecord::Base
  has_many :active_event_users,   -> { active },   class_name: "EventUser"
  has_many :inactive_event_users, -> { inactive }, class_name: "EventUser"

  has_many :inactive_events, through: :inactive_event_user,
                             class_name: "Event",
                             source: :event
  has_many :active_events,   through: :active_event_users,
                             class_name: "Event",
                             source: :event
end

La beauté de cette technique est que la fonctionnalité du cours d'un actif ou inactif de l'événement appartient à EventUser modèle, et si à l'avenir, la fonctionnalité doit être modifié, il serait modifiée dans un seul endroit: EventUser modèle, et les modifications seront prises en compte dans tous les autres modèles.

votre solution a fait ma journée 🙂

InformationsquelleAutor Arslan Ali

Vous devez vous connecter pour publier un commentaire.