Wie vermeidet man Duplikate in einer has_many: through-Beziehung?

Question

Wie kann ich Folgendes erreichen? Ich habe zwei Modelle (Blogs und Leser) und eine Tabelle JOIN, die mir erlauben, einen N zu haben: M Beziehung zwischen ihnen:

class Blog < ActiveRecord::Base 
    has_many :blogs_readers, :dependent => :destroy 
    has_many :readers, :through => :blogs_readers 
end 

class Reader < ActiveRecord::Base 
    has_many :blogs_readers, :dependent => :destroy 
    has_many :blogs, :through => :blogs_readers 
end 

class BlogsReaders < ActiveRecord::Base 
    belongs_to :blog 
    belongs_to :reader 
end 

Was ich jetzt tun möchte, ist Leser in den verschiedenen Blogs. Die Bedingung ist jedoch, dass ich nur einmal einen Leser zu einem Blog hinzufügen kann. Es darf also keine Duplikate (gleich readerID, gleich blogID) in der Tabelle BlogsReaders geben. Wie kann ich das erreichen? Die zweite Frage ist, wie bekomme ich eine Liste von Blogs, die die Leser nicht bereits abonniert haben (zB um eine Drop-down-Auswahlliste zu füllen, die dann verwendet werden kann, um den Leser zu einem anderen Blog hinzuzufügen). ?

Answer 1

Was:

Blog.find(:all, 
      :conditions => ['id NOT IN (?)', the_reader.blog_ids]) 

Rails kümmert sich um die Sammlung von ids für uns mit Assoziationsmethoden! :)

http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html

Answer 2

Dies sollte Ihre erste Frage kümmern:

class BlogsReaders < ActiveRecord::Base 
    belongs_to :blog 
    belongs_to :reader 

    validates_uniqueness_of :reader_id, :scope => :blog_id 
end 

Answer 3

Ich denke, jemand als dies mit einer besseren Antwort kommen wird.

the_reader = Reader.find(:first, :include => :blogs) 

Blog.find(:all, 
      :conditions => ['id NOT IN (?)', the_reader.blogs.map(&:id)]) 

[Bearbeiten]

Bitte sehen Joshs unten Antwort. Es ist der Weg zu gehen. (Ich wusste, dass es einen besseren Weg gibt;)

Answer 4

Einfachere Lösung, die in Rails gebaut ist:

class Blog < ActiveRecord::Base 
    has_many :blogs_readers, :dependent => :destroy 
    has_many :readers, :through => :blogs_readers, :uniq => true 
    end 

    class Reader < ActiveRecord::Base 
    has_many :blogs_readers, :dependent => :destroy 
    has_many :blogs, :through => :blogs_readers, :uniq => true 
    end 

    class BlogsReaders < ActiveRecord::Base 
     belongs_to :blog 
     belongs_to :reader 
    end 

Hinweis die :uniq => true Option zum has_many Gespräch hinzugefügt.

Sie können auch has_and_belongs_to_many zwischen Blog und Reader berücksichtigen, es sei denn, Sie haben einige andere Attribute, die Sie auf dem Join-Modell haben möchten (was Sie derzeit nicht tun). Diese Methode hat auch eine :uniq Option.

Beachten Sie, dass dies Sie nicht daran hindert, die Einträge in der Tabelle zu erstellen, aber es stellt sicher, dass Sie beim Abfragen der Sammlung nur eines von jedem Objekt erhalten.

aktualisieren

In Rails 4 die Art und Weise über einen Umfang Block zu tun, ist es. Das Oben ändert sich zu.

class Blog < ActiveRecord::Base 
has_many :blogs_readers, dependent: :destroy 
has_many :readers, -> { uniq }, through: :blogs_readers 
end 

class Reader < ActiveRecord::Base 
has_many :blogs_readers, dependent: :destroy 
has_many :blogs, -> { uniq }, through: :blogs_readers 
end 

class BlogsReaders < ActiveRecord::Base 
    belongs_to :blog 
    belongs_to :reader 
end 

Answer 5

Die Antwort auf diesen Link zeigt, wie die „< <“ Methode zu überschreiben, ohne zu erreichen, was Sie suchen Ausnahmen oder die Schaffung eines separaten Verfahrens zu erhöhen: Rails idiom to avoid duplicates in has_many :through

Answer 6

Der einfachste Weg ist es, die Beziehung zu serialisieren ein Array in:

class Blog < ActiveRecord::Base 
    has_many :blogs_readers, :dependent => :destroy 
    has_many :readers, :through => :blogs_readers 
    serialize :reader_ids, Array 
end 

dann, wenn die Werte für die Leser zuweisen, gelten Sie sie als

blog.reader_ids = [1,2,3,4] 

Wenn Sie Beziehungen auf diese Weise zuweisen, werden Duplikate automatisch entfernt.

Answer 7

Die Rails 5.1 Weg

class Blog < ActiveRecord::Base 
has_many :blogs_readers, dependent: :destroy 
has_many :readers, -> { distinct }, through: :blogs_readers 
end 

class Reader < ActiveRecord::Base 
has_many :blogs_readers, dependent: :destroy 
has_many :blogs, -> { distinct }, through: :blogs_readers 
end 

class BlogsReaders < ActiveRecord::Base 
    belongs_to :blog 
    belongs_to :reader 
end 

Answer 8

Die Top-Antwort sagt derzeit uniq im proc zu verwenden:

class Blog < ActiveRecord::Base 
has_many :blogs_readers, dependent: :destroy 
has_many :readers, -> { uniq }, through: :blogs_readers 
end 

Dies ist jedoch die Beziehung in eine Anordnung tritt und können die Dinge brechen, sind erwartet Operationen auf einer Relation auszuführen, nicht auf einem Array.

Wenn Sie distinct verwenden es hält sie als Beziehung:

class Blog < ActiveRecord::Base 
has_many :blogs_readers, dependent: :destroy 
has_many :readers, -> { distinct }, through: :blogs_readers 
end