appartient à via des associations

Étant donné les associations suivantes, je dois faire référence au Questionqui Choiceest attaché par le Choicemodèle. J'ai essayé d'utiliser belongs_to :question, through: :answerpour effectuer cette action.

class User
  has_many :questions
  has_many :choices
end

class Question
  belongs_to :user
  has_many :answers
  has_one :choice, :through => :answer
end

class Answer
  belongs_to :question
end

class Choice
  belongs_to :user
  belongs_to :answer
  belongs_to :question, :through => :answer

  validates_uniqueness_of :answer_id, :scope => [ :question_id, :user_id ]
end

Je reçois

NameError Constante non initialisée User::Choice

quand j'essaye de faire current_user.choices

Cela fonctionne bien, si je n'inclus pas le

belongs_to :question, :through => :answer

Mais je veux l'utiliser parce que je veux pouvoir faire le validates_uniqueness_of

J'oublie probablement quelque chose de simple. Toute aide serait appréciée.

Une belongs_toassociation ne peut pas avoir d' :throughoption. Vous feriez mieux de mettre en cache le question_idon Choiceet d'ajouter un index unique à la table (surtout parce qu'il validates_uniqueness_ofest sujet à des conditions de concurrence).

Si vous êtes paranoïaque, ajoutez une validation personnalisée Choicequi confirme que la réponse question_idcorrespond, mais il semble que l'utilisateur final ne devrait jamais avoir la possibilité de soumettre des données qui créeraient ce type d'incohérence.

Vous pouvez également déléguer:

class Company < ActiveRecord::Base
  has_many :employees
  has_many :dogs, :through => :employees
end

class Employee < ActiveRescord::Base
  belongs_to :company
  has_many :dogs
end

class Dog < ActiveRecord::Base
  belongs_to :employee

  delegate :company, :to => :employee, :allow_nil => true
end

Utilisez simplement has_oneau lieu de belongs_todans votre :through, comme ceci:

class Choice
  belongs_to :user
  belongs_to :answer
  has_one :question, :through => :answer
end

Sans rapport, mais j'hésiterais à utiliser validates_uniqueness_of au lieu d'utiliser une contrainte unique appropriée dans votre base de données. Lorsque vous faites cela en rubis, vous avez des conditions de course.

Mon approche était de créer un attribut virtuel au lieu d'ajouter des colonnes de base de données.

class Choice
  belongs_to :user
  belongs_to :answer

  # ------- Helpers -------
  def question
    answer.question
  end

  # extra sugar
  def question_id
    answer.question_id
  end
end

Cette approche est assez simple, mais s'accompagne de compromis. Il faut que Rails se charge à answerpartir de la base de données, puis question. Cela peut être optimisé plus tard en chargeant avec impatience les associations dont vous avez besoin (c'est-à-dire c = Choice.first(include: {answer: :question})), cependant, si cette optimisation est nécessaire, la réponse de stephencelis est probablement une meilleure décision de performance.

Il y a un moment et un lieu pour certains choix, et je pense que ce choix est meilleur lors du prototypage. Je ne l'utiliserais pas pour le code de production à moins de savoir que c'était pour un cas d'utilisation peu fréquent.

Cela ressemble à ce que vous voulez, c'est un utilisateur qui a de nombreuses questions.
La question a de nombreuses réponses, dont l'une est le choix de l'utilisateur.

C'est ce que vous recherchez?

Je modéliserais quelque chose comme ça dans le sens suivant:

class User
  has_many :questions
end

class Question
  belongs_to :user
  has_many   :answers
  has_one    :choice, :class_name => "Answer"

  validates_inclusion_of :choice, :in => lambda { answers }
end

class Answer
  belongs_to :question
end

Vous ne pouvez donc pas avoir le comportement que vous souhaitez, mais vous pouvez faire quelque chose qui vous ressemble. Tu veux pouvoir faireChoice.first.question

ce que j'ai fait dans le passé est quelque chose comme ça

class Choice
  belongs_to :user
  belongs_to :answer
  validates_uniqueness_of :answer_id, :scope => [ :question_id, :user_id ]
  ...
  def question
    answer.question
  end
end

de cette façon, vous pouvez maintenant appeler la question sur Choice

Le has_many :choicescrée une association nommée choices, non choice. Essayez d'utiliser à la current_user.choicesplace.

Consultez la documentation ActiveRecord :: Associations pour plus d'informations sur la has_manymagie.