ruby-on-rails - validates - rails validations

accepts_nested_attributes_for con find_or_create?

Question

Estoy utilizando el método accepted_nested_attributes_for de Rails con gran éxito, pero ¿cómo puedo evitar que cree nuevos registros si ya existe un registro?

A modo de ejemplo:

Digamos que tengo tres modelos, Equipo, Membresía y Jugador, y cada equipo tiene_muchos jugadores a través de membresías, y los jugadores pueden pertenecer a muchos equipos. El modelo de equipo podría aceptar atributos anidados para jugadores, pero eso significa que cada jugador enviado a través del equipo combinado + jugador (s) se creará como un nuevo registro de jugador.

¿Cómo debo hacer las cosas si solo quiero crear un nuevo registro de jugador de esta manera si no hay un jugador con el mismo nombre? Si hay un jugador con el mismo nombre, no se deben crear nuevos registros de jugador, sino que se debe encontrar el jugador correcto y asociarlo con el nuevo récord del equipo.

Answer 1

Cuando define un gancho para asociaciones de autoguardado, la ruta de código normal se salta y en su lugar se invoca su método. Por lo tanto, puedes hacer esto:

class Post < ActiveRecord::Base
  belongs_to :author, :autosave => true
  accepts_nested_attributes_for :author

  # If you need to validate the associated record, you can add a method like this:
  #     validate_associated_record_for_author
  def autosave_associated_records_for_author
    # Find or create the author by name
    if new_author = Author.find_by_name(author.name)
      self.author = new_author
    else
      self.author.save!
    end
  end
end

Este código no ha sido probado, pero debería ser más o menos lo que necesita.

Answer 2

Cuando se utiliza :accepts_nested_attributes_for , el envío de la id de un registro existente hará que ActiveRecord actualice el registro existente en lugar de crear un nuevo registro. No estoy seguro de cómo es tu marcado, pero prueba algo como esto:

<%= text_field_tag "team[player][name]", current_player.name %>
<%= hidden_field_tag "team[player][id]", current_player.id if current_player %>

El nombre del jugador se actualizará si se proporciona el id , pero creado de otra manera.

El enfoque de definir autosave_associated_record_for_ method es muy interesante. ¡Ciertamente usaré eso! Sin embargo, considere esta solución más simple también.

Answer 3

Esto funciona muy bien si tienes una relación has_one o belongs_to. Pero se quedó corto con un has_many o has_many through.

Tengo un sistema de etiquetado que utiliza una relación has_many: through. Ninguna de las soluciones aquí me llevó a donde tenía que ir, así que se me ocurrió una solución que puede ayudar a otros. Esto ha sido probado en Rails 3.2.

Preparar

Aquí hay una versión básica de mis modelos:

Objeto de ubicación:

class Location < ActiveRecord::Base
    has_many :city_taggables, :as => :city_taggable, :dependent => :destroy
    has_many :city_tags, :through => :city_taggables

    accepts_nested_attributes_for :city_tags, :reject_if => :all_blank, allow_destroy: true
end

Tag Objects

class CityTaggable < ActiveRecord::Base
   belongs_to :city_tag
   belongs_to :city_taggable, :polymorphic => true
end

class CityTag < ActiveRecord::Base
   has_many :city_taggables, :dependent => :destroy
   has_many :ads, :through => :city_taggables
end

Solución

De hecho, anulé el método autosave_associated_recored_for de la siguiente manera:

class Location < ActiveRecord::Base
   private

   def autosave_associated_records_for_city_tags
     tags =[]
     #For Each Tag
     city_tags.each do |tag|
       #Destroy Tag if set to _destroy
       if tag._destroy
         #remove tag from object don''t destroy the tag
         self.city_tags.delete(tag)
         next
       end

       #Check if the tag we are saving is new (no ID passed)
       if tag.new_record?
         #Find existing tag or use new tag if not found
         tag = CityTag.find_by_label(tag.label) || CityTag.create(label: tag.label)
       else
         #If tag being saved has an ID then it exists we want to see if the label has changed
         #We find the record and compare explicitly, this saves us when we are removing tags.
         existing = CityTag.find_by_id(tag.id)
         if existing    
           #Tag labels are different so we want to find or create a new tag (rather than updating the exiting tag label)
           if tag.label != existing.label
             self.city_tags.delete(tag)
             tag = CityTag.find_by_label(tag.label) || CityTag.create(label: tag.label)
           end
         else
           #Looks like we are removing the tag and need to delete it from this object
           self.city_tags.delete(tag)
           next
         end
       end
       tags << tag
     end
     #Iterate through tags and add to my Location unless they are already associated.
     tags.each do |tag|
       unless tag.in? self.city_tags
         self.city_tags << tag
       end
     end
   end

La implementación anterior guarda, elimina y cambia las etiquetas de la forma que necesitaba al usar fields_for en forma anidada. Estoy abierto a comentarios si hay formas de simplificar. Es importante señalar que estoy cambiando explícitamente las etiquetas cuando la etiqueta cambia en lugar de actualizar la etiqueta.

Answer 4

La respuesta de @dustin-m fue instrumental para mí: estoy haciendo algo personalizado con una relación has_many: through. Tengo un tema que tiene una tendencia, que tiene muchos hijos (recursivo).

ActiveRecord no le gusta cuando configuro esto como un estándar has_many :searches, through: trend, source: :children relationship. Recupera topic.trend y topic.searches pero no hará topic.searches.create (name: foo).

Así que utilicé lo anterior para construir un autoguardado personalizado y estoy logrando el resultado correcto con accepts_nested_attributes_for :searches, allow_destroy: true def autosave_associated_records_for_searches searches.each do | s | if s._destroy self.trend.children.delete(s) elsif s.new_record? self.trend.children << s else s.save end end end def autosave_associated_records_for_searches searches.each do | s | if s._destroy self.trend.children.delete(s) elsif s.new_record? self.trend.children << s else s.save end end end

Answer 5

No piense que se trata de agregar jugadores a equipos, piense que se trata de agregar membresías a equipos. La forma no funciona con los jugadores directamente. El modelo de membresía puede tener un player_name virtual player_name . Detrás de escena, esto puede buscar a un jugador o crear uno.

class Membership < ActiveRecord::Base
  def player_name
    player && player.name
  end

  def player_name=(name)
    self.player = Player.find_or_create_by_name(name) unless name.blank?
  end
end

Y luego simplemente agregue un campo de texto player_name a cualquier creador de formularios de Membresía.

<%= f.text_field :player_name %>

De esta forma, no es específico de accept_nested_attributes_for y se puede usar en cualquier formulario de membresía.

Nota: con esta técnica, el modelo Player se crea antes de que se realice la validación. Si no desea este efecto, guarde el reproductor en una variable de instancia y guárdelo en una devolución de llamada before_save.

Answer 6

Para redondear las cosas en términos de la pregunta (se refiere a find_or_create), el bloque if en la respuesta de Francois podría reformularse como:

self.author = Author.find_or_create_by_name(author.name) unless author.name.blank?
self.author.save! 

Answer 7

Respuesta de @ François Beausoleil es increíble y resolvió un gran problema. Genial para aprender sobre el concepto de autosave_associated_record_for .

Sin embargo, encontré un caso de esquina en esta implementación. En caso de update del autor de la publicación existente ( A1 ), si se pasa un nuevo nombre de autor ( A2 ), terminará cambiando el nombre del autor original ( A1 ).

p = Post.first
p.author #<Author id: 1, name: ''JK Rowling''>
# now edit is triggered, and new author(non existing) is passed(e.g: Cal Newport).

p.author #<Author id: 1, name: ''Cal Newport''>

Código Oringinal:

class Post < ActiveRecord::Base
  belongs_to :author, :autosave => true
  accepts_nested_attributes_for :author

  # If you need to validate the associated record, you can add a method like this:
  #     validate_associated_record_for_author
  def autosave_associated_records_for_author
    # Find or create the author by name
    if new_author = Author.find_by_name(author.name)
      self.author = new_author
    else
      self.author.save!
    end
  end
end

Es porque, en caso de edición, self.author para publicación ya será un autor con id: 1, irá en else, bloqueará y actualizará ese author lugar de crear uno nuevo.

Cambié el código (condición elsif ) para mitigar este problema:

class Post < ActiveRecord::Base
  belongs_to :author, :autosave => true
  accepts_nested_attributes_for :author

  # If you need to validate the associated record, you can add a method like this:
  #     validate_associated_record_for_author
  def autosave_associated_records_for_author
    # Find or create the author by name
    if new_author = Author.find_by_name(author.name)
      self.author = new_author
    elsif author && author.persisted? && author.changed?
      # New condition: if author is already allocated to post, but is changed, create a new author.
      self.author = Author.new(name: author.name)
    else
      # else create a new author
      self.author.save!
    end
  end
end

Answer 8

Un gancho before_validation es una buena opción: es un mecanismo estándar que da como resultado un código más simple que la anulación de los autosave_associated_records_for_* más oscuros.

class Quux < ActiveRecord::Base

  has_and_belongs_to_many :foos
  accepts_nested_attributes_for :foos, reject_if: ->(object){ object[:value].blank? }
  before_validation :find_foos

  def find_foos
    self.foos = self.foos.map do |object|
      Foo.where(value: object.value).first_or_initialize
    end
  end

end