Scalanie dwóch/trzech rekordów w szynach

Question

Chcę połączyć dwa profile w jeden. Jaki jest najlepszy sposób na zrobienie tego w Railsach.

Mam dwa profile: user1 i user2 i jest z nimi co najmniej 30 tabel.

Teraz chcę połączyć je razem więc, że powinien istnieć jeden profil powiedzieć user1 i user2 powinny zostaną usunięte ale cała związana danych user2 teraz powinien stowarzyszona z user1.

Na przykład: załóżmy, że user2 ma dwa kontakty i user1 ma 3 kontakty po scaleniu użytkownika user1 powinien mieć 5 kontaktów.

Answer 1

coś takiego

@user1 = User.find(1); 
@user2 = User.find(2); 

Contact.where("user_id = ?", @user2.id).update_all(:user_id => @user1.id) 
@user2.destroy 

w przypadku rozwiązania uogólniać miejsce pliku /lib/acts_as_user_merge.rb

module UserMerge 
    module ActsAsUserMerge 
    module Base 
     def self.included(klass) 
     klass.class_eval do 
      extend Config 
     end 
     end 
    end 

    module Config 
     def acts_as_user_merge 
      include ::UserMerge::ActsAsUserMerge::InstanceMethods 
     end 
    end 

    module InstanceMethods  
     def merge(user) 
     models = Array.new 
     models_names = User.reflections.collect{|a, b| b.class_name if b.macro==:has_many}.compact 
     models_names.each do |name| 
      models << Object.const_get name 
     end 
     models.each do |model| 
      model.where("user_id = ?", user.id).update_all(:user_id => self.id) 
     end 
     user.destroy 
     end 
    end 
    end 
end 

::ActiveRecord::Base.send :include, ::UserMerge::ActsAsUserMerge::Base 

jak używać

User < ActiveRecord::Base 
    has_many ... 

    acts_as_user_merge 

end 

@user1.merge(@user2) 

trochę brudny i nie testowane ale powinien dać ci pomysł

Answer 2

coś w tym

def merge_users(dead, user) 
    User.reflections.each do |assoc, reflection| 
    foreign_key = reflection.foreign_key 
    case reflection.macro 
    when :has_many, :has_one then 
     unless reflection.options[:through] 
     reflection.klass.where(foreign_key => dead.id).update_all(foreign_key => user.id) # if id is a primary key 
     end 
     if options[:as] # polymorphic 
     if reflection.macro == :has_many 
      dead.send("#{options[:as].pluralize}")).each { |r| user.send("#{options[:as].pluralize}<<", r) } 
     else 
      user.send("#{options[:as]}=", dead.send("#{options[:as]}")) 
      user.save 
     end 
     end 
    when :belongs_to then 
     if options[:polymorphic] 
     user.send("#{assoc}=", deaf.send(assoc)) 
     user.save 
     else 
     user.update_attribute(foreign_key, dead.send(foreign_key)) 
     end 
    when :has_and_belongs_to_many then 
     dead.send("#{assoc}")).each { |r| user.send("#{assoc}<<", r) } 
    end 

    end 
end 

merge_users(dead_user, user) 
dead_user.destroy 

Answer 3

tym artykule omówiono tę sprawę dogłębnie i dostarcza kod pracy dla niego: http://ewout.name/2010/04/generic-deep-merge-for-activerecord/