ruby-on-rails - has_one - rails has_many through example

¿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 JOIN que me permitirán 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 agregar 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 (mismo readerID , 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 ya no están suscritos (por ejemplo, para completar una lista de selección desplegable, que luego puede usarse para agregar el lector a otro blog)?

Answer 1

La forma Rails 5.1

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 2

Esto debería encargarse de tu 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 vendrá con una mejor respuesta que esta.

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

[editar]

Por favor, vea la respuesta de Josh a continuación. Es el camino a seguir. (Sabía que había una mejor manera de salir de allí;)

Answer 4

Qué pasa:

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

¡Rails se encarga de la recopilación de identificadores para nosotros con los métodos de asociación! :)

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

Answer 5

Una solución más simple que está integrada en Rails:

 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

Tenga en cuenta que agrega 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 unión (que no tiene actualmente). Ese método también tiene :uniq opiton :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.

Actualizar

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 6

La forma más fácil es 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, al asignar valores a los lectores, los aplica como

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

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

Answer 7

La respuesta en este enlace muestra cómo anular el método "<<" para lograr lo que está buscando sin generar excepciones o crear un método separado: Rails idioma para evitar duplicados en has_many: a través de

Answer 8

La respuesta principal actualmente dice usar uniq en el proceso:

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

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

Si usa 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