cómo evitar duplicados en una relación has_many: through?

Question

¿Cómo puedo lograr lo siguiente? Tengo dos modelos (blogs y lectores) y una tabla de unión que me permite tener una relación N: M entre ellos:

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 

Lo que quiero hacer ahora, es añadir a los lectores a diferentes blogs. La condición, sin embargo, es que solo puedo agregar un lector a un blog UNA VEZ. Por lo tanto, no debe haber ningún duplicado (el mismo readerID, el mismo blogID) en la tabla BlogsReaders. ¿Cómo puedo conseguir esto?

La segunda pregunta es, ¿cómo obtengo una lista de blog a la que los lectores no están suscritos (por ejemplo, para completar una lista desplegable, que luego puede usarse para agregar el lector a otro blog) ?

Answer 1

¿Qué hay de:

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

rieles se encarga de la recogida de identificadores para nosotros, con métodos de asociación! :)

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

Answer 2

Esto debe hacerse cargo de su primera pregunta:

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

    validates_uniqueness_of :reader_id, :scope => :blog_id 
end 

Answer 3

Estoy pensando que alguien va a llegar con una respuesta mejor que esto.

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

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

[editar]

Por favor, véase la respuesta de Josh continuación. Es el camino a seguir. (Sabía que había una manera mejor por ahí;)

Answer 4

sencilla solución que se construye en los rieles:

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 

Nota añadiendo la opción :uniq => true a la llamada has_many.

También es posible que desee considerar has_and_belongs_to_many entre Blog y Reader, a menos que tenga otros atributos que le gustaría tener en el modelo de combinación (que actualmente no tiene). Ese método también tiene una opción de :uniq.

Tenga en cuenta que esto no le impide crear las entradas en la tabla, pero sí garantiza que cuando consulte la colección obtendrá solo una de cada objeto.

actualización

En Rails 4 la forma de hacerlo es a través de un bloque de alcance. Lo anterior cambia a.

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

La respuesta en este enlace muestra cómo reemplazar el método "< <" para lograr lo que busca sin levantar excepciones o la creación de un método separado: Rails idiom to avoid duplicates in has_many :through

Answer 6

La manera más fácil es para serializar la relación en una matriz:

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

Luego, cuando la asignación de valores a los lectores, se las aplica como

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

Al asignar relaciones de esta manera, los duplicados se eliminan automáticamente.

Answer 7

Los rieles 5,1 manera

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

La respuesta más común actualmente dice que use uniq en el proc:

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

Sin embargo, esto se inicia la relación en una matriz y puede romper las cosas que son esperando realizar operaciones en una relación, no en una matriz.

Si utiliza distinct lo mantiene como una relación:

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