przynależy_to poprzez skojarzenia

Biorąc pod uwagę następujące skojarzenia, muszę odnieść się do tego, Questionże a Choicejest dołączone przez Choicemodel. Próbowałem użyć belongs_to :question, through: :answerdo wykonania tej czynności.

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

staje się

NameError uninitialized constant User::Choice

kiedy próbuję to zrobić current_user.choices

Działa dobrze, jeśli nie dołączę rozszerzenia

belongs_to :question, :through => :answer

Ale chcę tego użyć, ponieważ chcę mieć możliwość wykonania validates_uniqueness_of

Prawdopodobnie przeoczę coś prostego. Każda pomoc będzie mile widziana.

belongs_toStowarzyszenie nie może mieć :throughopcję. Lepiej jest buforować question_idwłączone Choicei dodać unikalny indeks do tabeli (zwłaszcza, że validates_uniqueness_ofjest podatny na warunki wyścigu).

Jeśli masz paranoję, dodaj niestandardową weryfikację, Choicektóra potwierdzi, że odpowiedź jest question_idzgodna, ale wygląda na to, że użytkownik nigdy nie powinien mieć możliwości przesłania danych, które spowodowałyby tego rodzaju niezgodność.

Możesz również delegować:

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

Po prostu użyj has_onezamiast belongs_tow swoim :through, na przykład:

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

Bez związku, ale wahałbym się, czy użyć validates_uniqueness_of zamiast używać odpowiedniego unikalnego ograniczenia w Twojej bazie danych. Kiedy robisz to w rubinie, masz warunki wyścigu.

Moje podejście polegało na stworzeniu wirtualnego atrybutu zamiast dodawania kolumn bazy danych.

class Choice
  belongs_to :user
  belongs_to :answer

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

  # extra sugar
  def question_id
    answer.question_id
  end
end

To podejście jest dość proste, ale wiąże się z kompromisami. Wymaga załadowania Railsów answerz bazy danych, a następnie question. Można to później zoptymalizować, chętnie ładując potrzebne skojarzenia (tj. c = Choice.first(include: {answer: :question})), Jednak jeśli ta optymalizacja jest konieczna, wówczas odpowiedź Stephencelisa jest prawdopodobnie lepszą decyzją dotyczącą wydajności.

Jest czas i miejsce na pewne wybory i myślę, że ten wybór jest lepszy przy prototypowaniu. Nie użyłbym go do kodu produkcyjnego, chyba że wiedziałbym, że jest to rzadki przypadek użycia.

Wygląda na to, że chcesz, aby użytkownik miał wiele pytań.
Pytanie ma wiele odpowiedzi, z których jedną jest wybór użytkownika.

Czy tego szukasz?

Wymodelowałbym coś takiego w następujący sposób:

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

Więc nie możesz zachowywać się tak, jak chcesz, ale możesz zrobić coś, na co masz ochotę. Chcesz móc to zrobićChoice.first.question

to, co zrobiłem w przeszłości, przypomina coś takiego

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

w ten sposób możesz teraz zadać pytanie o wybór

has_many :choicesTworzy stowarzyszenie nazwane choices, nie choice. Spróbuj użyć current_user.choiceszamiast tego.

Zobacz dokumentację ActiveRecord :: Associations, aby uzyskać informacje o has_manymagii.