Merge branch 'story/113066359-optimization' into staging

# Conflicts:
#	app/jobs/regenerate_registrar_whoises_job.rb
#	app/jobs/regenerate_whois_record_job.rb
#	app/models/blocked_domain.rb

app/jobs/regenerate_registrar_whoises_job.rb

@@ -3,8 +3,8 @@ class RegenerateRegistrarWhoisesJob < Que::Job
     # no return as we want restart job if fails
     registrar = Registrar.find(registrar_id)
 
-    registrar.whois_records.select(:id).find_in_batches(batch_size: 20) do |group|
-      RegenerateWhoisRecordJob.enqueue group.map(&:id), :id
+    registrar.whois_records.select(:name).find_in_batches(batch_size: 20) do |group|
+      UpdateWhoisRecordJob.enqueue group.map(&:name), 'domain'
     end
   end
 end

app/jobs/regenerate_whois_record_job.rb

@@ -1,10 +0,0 @@
-class RegenerateWhoisRecordJob < Que::Job
-  def run(ids, attr = :id)
-    ids.each do |id|
-      record = WhoisRecord.find_by(attr => id)
-      return unless record
-
-      record.save
-    end
-  end
-end

app/jobs/update_whois_record_job.rb

@@ -1,16 +1,52 @@
 class UpdateWhoisRecordJob < Que::Job
 
-  def run(ids, type)
+  def run(names, type)
     klass = case type
       when 'reserved'then ReservedDomain
       when 'blocked' then BlockedDomain
-      else Domain
+      when 'domain'  then Domain
     end
 
-    ids.each do |id|
-      record = klass.find_by(id: id)
-      next unless record
-      record.update_whois_record
+    Array(names).each do |name|
+      record = klass.find_by(name: name)
+      if record
+        send "update_#{type}", record
+      else
+        send "delete_#{type}", name
+      end
     end
   end
+
+
+
+  def update_domain(domain)
+    domain.whois_record ? domain.whois_record.save : domain.create_whois_record
+  end
+
+  def update_reserved(record)
+    record.generate_data
+  end
+
+  def update_blocked(record)
+    update_reserved(record)
+  end
+
+
+  # 1. deleting own
+  # 2. trying to regenerate reserved in order domain is still in the list
+  def delete_domain(name)
+    WhoisRecord.where(name: name).destroy_all
+
+    BlockedDomain.find_by(name: name).try(:generate_data)
+    ReservedDomain.find_by(name: name).try(:generate_data)
+  end
+
+  def delete_reserved(name)
+    Domain.where(name: name).any?
+    Whois::Record.where(name: name).delete_all
+  end
+
+  def delete_blocked(name)
+    delete_reserved(name)
+  end
 end

app/models/blocked_domain.rb

@@ -1,7 +1,8 @@
 class BlockedDomain < ActiveRecord::Base
   include Versions
-  before_save :generate_data
-  before_destroy :remove_data
+  before_save   :generate_data
+  after_destroy :remove_data
+
   validates :name, domain_name: true, uniqueness: true
 
 
@@ -22,19 +23,14 @@ class BlockedDomain < ActiveRecord::Base
   def generate_data
     return if Domain.where(name: name).any?
 
-    @json = generate_json
-    @body = generate_body
-    update_whois_server
+    wr = Whois::Record.find_or_initialize_by(name: name)
+    wr.json = @json = generate_json # we need @json to bind to class
+    wr.body = generate_body
+    wr.save
   end
 
   alias_method :update_whois_record, :generate_data
 
-  def update_whois_server
-    wr = Whois::Record.find_or_initialize_by(name: name)
-    wr.body = @body
-    wr.json = @json
-    wr.save
-  end
 
   def generate_body
     template = Rails.root.join("app/views/for_models/whois_other.erb".freeze)
@@ -49,8 +45,6 @@ class BlockedDomain < ActiveRecord::Base
   end
 
   def remove_data
-    return if Domain.where(name: name).any?
-
-    Whois::Record.where(name: name).delete_all
+    UpdateWhoisRecordJob.enqueue name, 'blocked'
   end
 end

app/models/domain.rb

@@ -45,7 +45,7 @@ class Domain < ActiveRecord::Base
   has_many :dnskeys, dependent: :destroy
 
   has_many :keyrelays
-  has_one :whois_record, dependent: :destroy
+  has_one  :whois_record # destroyment will be done in after_commit
 
   accepts_nested_attributes_for :dnskeys, allow_destroy: true
 
@@ -89,14 +89,11 @@ class Domain < ActiveRecord::Base
     true
   end
 
-  after_save :update_whois_record
+  after_commit :update_whois_record
 
   after_create :update_reserved_domains
   def update_reserved_domains
-    return unless in_reserved_list?
-    rd = ReservedDomain.by_domain(name).first
-    rd.password = SecureRandom.hex
-    rd.save
+    ReservedDomain.new_password_for(name) if in_reserved_list?
   end
 
   validates :name_dirty, domain_name: true, uniqueness: true
@@ -286,7 +283,7 @@ class Domain < ActiveRecord::Base
   end
 
   def in_reserved_list?
-    ReservedDomain.pw_for(name).present?
+    @in_reserved_list ||= ReservedDomain.by_domain(name).any?
   end
 
   def pending_transfer
@@ -758,7 +755,7 @@ class Domain < ActiveRecord::Base
   end
 
   def update_whois_record
-    whois_record.blank? ? create_whois_record : whois_record.save
+    UpdateWhoisRecordJob.enqueue name, 'domain'
   end
 
   def status_notes_array=(notes)

app/models/reserved_domain.rb

@@ -2,7 +2,8 @@ class ReservedDomain < ActiveRecord::Base
   include Versions # version/reserved_domain_version.rb
   before_save :fill_empty_passwords
   before_save :generate_data
-  before_destroy :remove_data
+  after_destroy :remove_data
+
   validates :name, domain_name: true, uniqueness: true
 
 
@@ -21,38 +22,40 @@ class ReservedDomain < ActiveRecord::Base
     def any_of_domains names
       where(name: names)
     end
-  end
 
+    def new_password_for name
+      record = by_domain(name).first
+      return unless record
 
-  def fill_empty_passwords
-
-    if self.password.empty?
-
-      self.password =  SecureRandom.hex
-
+      record.regenerate_password
+      record.save
     end
   end
 
+
+
   def name= val
     super SimpleIDN.to_unicode(val)
   end
 
+  def fill_empty_passwords
+    regenerate_password if self.password.blank?
+  end
+
+  def regenerate_password
+    self.password = SecureRandom.hex
+  end
+
   def generate_data
     return if Domain.where(name: name).any?
 
-    @json = generate_json
-    @body = generate_body
-    update_whois_server
-  end
-
-  alias_method :update_whois_record, :generate_data
-
-  def update_whois_server
     wr = Whois::Record.find_or_initialize_by(name: name)
-    wr.body = @body
-    wr.json = @json
+    wr.json = @json = generate_json # we need @json to bind to class
+    wr.body = generate_body
     wr.save
   end
+  alias_method :update_whois_record, :generate_data
+
 
   def generate_body
     template = Rails.root.join("app/views/for_models/whois_other.erb".freeze)
@@ -67,9 +70,7 @@ class ReservedDomain < ActiveRecord::Base
   end
 
   def remove_data
-    return if Domain.where(name: name).any?
-
-    Whois::Record.where(name: name).delete_all
+    UpdateWhoisRecordJob.enqueue name, 'reserved'
   end
 
 end

lib/tasks/whois.rake

@@ -8,17 +8,17 @@ namespace :whois do
 
       print "\n-----> Update domains whois_records"
       Domain.find_in_batches.each do |group|
-        UpdateWhoisRecordJob.enqueue group.map(&:id), 'domain'
+        UpdateWhoisRecordJob.enqueue group.map(&:name), 'domain'
       end
 
       print "\n-----> Update blocked domains whois_records"
       BlockedDomain.find_in_batches.each do |group|
-        UpdateWhoisRecordJob.enqueue group.map(&:id), 'blocked'
+        UpdateWhoisRecordJob.enqueue group.map(&:name), 'blocked'
       end
 
       print "\n-----> Update reserved domains whois_records"
       ReservedDomain.find_in_batches.each do |group|
-        UpdateWhoisRecordJob.enqueue group.map(&:id), 'reserved'
+        UpdateWhoisRecordJob.enqueue group.map(&:name), 'reserved'
       end
 
     end