Quelle est la façon la plus simple de dupliquer un enregistrement activerecord?

Je veux faire une copie d'un enregistrement activerecord, en changeant un seul champ dans le processus (en plus de l' id ). Quelle est la manière la plus simple d'y parvenir?

Je me rends compte que je pourrais créer un nouvel enregistrement, puis itérer sur chacun des champs en copiant les données champ par champ - mais je me suis dit qu'il devait y avoir un moyen plus simple de le faire ...

tel que:

 @newrecord=Record.copy(:id)  *perhaps?*

Pour obtenir une copie, utilisez la méthode clone (ou dup for rails 3.1+):

# rails < 3.1
new_record = old_record.clone

#rails >= 3.1
new_record = old_record.dup

Ensuite, vous pouvez modifier les champs que vous souhaitez.

ActiveRecord remplace le clone Object # intégré pour vous donner un nouvel enregistrement (non enregistré dans la base de données) avec un ID non attribué.
Notez qu'il ne copie pas les associations, vous devrez donc le faire manuellement si vous en avez besoin.

Le clone de Rails 3.1 est une copie superficielle, utilisez plutôt dup ...

Selon vos besoins et votre style de programmation, vous pouvez également utiliser une combinaison de la nouvelle méthode de la classe et de la fusion. Faute d'un meilleur simple exemple , supposons qu'une tâche soit planifiée pour une certaine date et que vous souhaitiez la dupliquer à une autre date. Les attributs réels de la tâche ne sont pas importants, donc:

old_task = Task.find (task_id)
new_task = Task.new (old_task.attributes.merge ({: schedule_on => some_new_date}))

créera une nouvelle tâche avec :id => nil, :scheduled_on => some_new_dateet tous les autres attributs de la même chose que la tâche d' origine. En utilisant Task.new, vous devrez appeler explicitement save, donc si vous voulez qu'il soit enregistré automatiquement, changez Task.new en Task.create.

Paix.

Vous aimerez peut-être aussi la gemme Amoeba pour ActiveRecord 3.2.

Dans votre cas, vous souhaiterez probablement utiliser le nullify, regexouprefix des options disponibles dans le DSL de configuration.

Il prend en charge la duplication récursive facile et automatique has_one, has_manyet les has_and_belongs_to_manyassociations, le prétraitement sur le terrain et une configuration DSL hautement flexible et puissante qui peut être appliquée à la fois au modèle et à la volée.

assurez-vous de consulter la documentation d'Amoeba mais l'utilisation est assez facile ...

juste

gem install amoeba

ou ajouter

gem 'amoeba'

à votre Gemfile

puis ajoutez le bloc amibe à votre modèle et exécutez la dupméthode comme d'habitude

class Post < ActiveRecord::Base
  has_many :comments
  has_and_belongs_to_many :tags

  amoeba do
    enable
  end
end

class Comment < ActiveRecord::Base
  belongs_to :post
end

class Tag < ActiveRecord::Base
  has_and_belongs_to_many :posts
end

class PostsController < ActionController
  def some_method
    my_post = Post.find(params[:id])
    new_post = my_post.dup
    new_post.save
  end
end

Vous pouvez également contrôler les champs qui seront copiés de nombreuses manières, mais par exemple, si vous vouliez empêcher la duplication des commentaires mais que vous vouliez conserver les mêmes balises, vous pourriez faire quelque chose comme ceci:

class Post < ActiveRecord::Base
  has_many :comments
  has_and_belongs_to_many :tags

  amoeba do
    exclude_field :comments
  end
end

Vous pouvez également prétraiter les champs pour aider à indiquer l'unicité des préfixes et suffixes ainsi que des regex. En outre, il existe également de nombreuses options pour que vous puissiez écrire dans le style le plus lisible à votre intention:

class Post < ActiveRecord::Base
  has_many :comments
  has_and_belongs_to_many :tags

  amoeba do
    include_field :tags
    prepend :title => "Copy of "
    append :contents => " (copied version)"
    regex :contents => {:replace => /dog/, :with => "cat"}
  end
end

La copie récursive des associations est facile, activez simplement l'amibe sur les modèles enfants

class Post < ActiveRecord::Base
  has_many :comments

  amoeba do
    enable
  end
end

class Comment < ActiveRecord::Base
  belongs_to :post
  has_many :ratings

  amoeba do
    enable
  end
end

class Rating < ActiveRecord::Base
  belongs_to :comment
end

La configuration DSL a encore plus d'options, alors assurez-vous de consulter la documentation.

Prendre plaisir! :)

Utilisez ActiveRecord :: Base # dup si vous ne voulez pas copier l'identifiant

Je copie généralement les attributs, en changeant tout ce que j'ai besoin de changer:

new_user = User.new(old_user.attributes.merge(:login => "newlogin"))

Si vous avez besoin d'une copie complète avec des associations, je recommande la gemme deep_cloneable .

Dans Rails 5, vous pouvez simplement créer un objet en double ou enregistrer comme ceci.

new_user = old_user.dup

Le moyen le plus simple est:

#your rails >= 3.1 (i was done it with Rails 5.0.0.1)
  o = Model.find(id)
 # (Range).each do |item|
 (1..109).each do |item|
   new_record = o.dup
   new_record.save
 end

Ou

# if your rails < 3.1
 o = Model.find(id)
 (1..109).each do |item|
   new_record = o.clone
   new_record.save
 end     

Voici un exemple de #dupméthode ActiveRecord prioritaire pour personnaliser la duplication d'instance et inclure également la duplication de relation:

class Offer < ApplicationRecord
  has_many :offer_items

  def dup
    super.tap do |new_offer|

      # change title of the new instance
      new_offer.title = "Copy of #{@offer.title}"

      # duplicate offer_items as well
      self.offer_items.each { |offer_item| new_offer.offer_items << offer_item.dup }
    end
  end
end

Remarque: cette méthode ne nécessite aucune gemme externe mais elle nécessite une version plus récente d'ActiveRecord avec la #dupméthode implémentée

Vous pouvez également vérifier la gemme actes_as_inheritable .

"Agit en tant qu'héritable est une gemme Ruby spécifiquement écrite pour les modèles Rails / ActiveRecord. Elle est destinée à être utilisée avec l'association auto-référentielle , ou avec un modèle dont un parent partage les attributs héritables. Cela vous permettra d'hériter de tout attribut ou relation du modèle parent. "

En ajoutant acts_as_inheritableà vos modèles, vous aurez accès à ces méthodes:

inherit_attributes

class Person < ActiveRecord::Base

  acts_as_inheritable attributes: %w(favorite_color last_name soccer_team)

  # Associations
  belongs_to  :parent, class_name: 'Person'
  has_many    :children, class_name: 'Person', foreign_key: :parent_id
end

parent = Person.create(last_name: 'Arango', soccer_team: 'Verdolaga', favorite_color:'Green')

son = Person.create(parent: parent)
son.inherit_attributes
son.last_name # => Arango
son.soccer_team # => Verdolaga
son.favorite_color # => Green

inherit_relations

class Person < ActiveRecord::Base

  acts_as_inheritable associations: %w(pet)

  # Associations
  has_one     :pet
end

parent = Person.create(last_name: 'Arango')
parent_pet = Pet.create(person: parent, name: 'Mango', breed:'Golden Retriver')
parent_pet.inspect #=> #<Pet id: 1, person_id: 1, name: "Mango", breed: "Golden Retriver">

son = Person.create(parent: parent)
son.inherit_relations
son.pet.inspect # => #<Pet id: 2, person_id: 2, name: "Mango", breed: "Golden Retriver">

J'espère que cela peut vous aider.

Puisqu'il pourrait y avoir plus de logique, lors de la duplication d'un modèle, je suggère de créer une nouvelle classe, où vous manipulez toute la logique nécessaire. Pour faciliter cela, il existe un joyau qui peut vous aider: clowne

Selon leurs exemples de documentation, pour un modèle utilisateur:

class User < ActiveRecord::Base
  # create_table :users do |t|
  #  t.string :login
  #  t.string :email
  #  t.timestamps null: false
  # end

  has_one :profile
  has_many :posts
end

Vous créez votre classe de cloneur:

class UserCloner < Clowne::Cloner
  adapter :active_record

  include_association :profile, clone_with: SpecialProfileCloner
  include_association :posts

  nullify :login

  # params here is an arbitrary Hash passed into cloner
  finalize do |_source, record, params|
    record.email = params[:email]
  end
end

class SpecialProfileCloner < Clowne::Cloner
  adapter :active_record

  nullify :name
end

puis l'utiliser:

user = User.last
#=> <#User(login: 'clown', email: 'clown@circus.example.com')>

cloned = UserCloner.call(user, email: 'fake@example.com')
cloned.persisted?
# => false

cloned.save!
cloned.login
# => nil
cloned.email
# => "fake@example.com"

# associations:
cloned.posts.count == user.posts.count
# => true
cloned.profile.name
# => nil

Exemple copié du projet, mais il donnera une vision claire de ce que vous pouvez réaliser.

Pour un enregistrement simple et rapide, je choisirais:

Model.new(Model.last.attributes.reject {|k,_v| k.to_s == 'id'}