MERGE: merged staging at 3235647, resolved merge conflict

app/models/contact.rb

@@ -345,6 +345,10 @@ class Contact < ActiveRecord::Base
     end
   end
 
+  def search_name
+    "#{code} #{name}"
+  end
+
   def set_linked
     statuses << LINKED if statuses.detect { |s| s == LINKED }.blank?
   end

app/models/domain.rb

@@ -257,7 +257,7 @@ class Domain < ActiveRecord::Base
         next unless domain.expirable?
         domain.set_graceful_expired
         STDOUT << "#{Time.zone.now.utc} Domain.start_expire_period: ##{domain.id} (#{domain.name}) #{domain.changes}\n" unless Rails.env.test?
-        domain.save(validate: false)
+        domain.save
       end
 
       STDOUT << "#{Time.zone.now.utc} - Successfully expired #{domains.count} domains\n" unless Rails.env.test?
@@ -370,13 +370,16 @@ class Domain < ActiveRecord::Base
 
   def renewable?
     if Setting.days_to_renew_domain_before_expire != 0
-      if ((valid_to - Time.zone.now.beginning_of_day).to_i / 1.day) + 1 > Setting.days_to_renew_domain_before_expire
+      # if you can renew domain at days_to_renew before domain expiration
+      if (valid_to.to_date - Date.today) + 1 > Setting.days_to_renew_domain_before_expire
         return false
       end
     end
 
-    return false if statuses.include?(DomainStatus::DELETE_CANDIDATE) || statuses.include?(DomainStatus::FORCE_DELETE)
-
+    return false if statuses.include_any?(DomainStatus::DELETE_CANDIDATE, DomainStatus::SERVER_RENEW_PROHIBITED,
+                                          DomainStatus::CLIENT_RENEW_PROHIBITED, DomainStatus::PENDING_RENEW,
+                                          DomainStatus::PENDING_TRANSFER, DomainStatus::PENDING_DELETE,
+                                          DomainStatus::PENDING_UPDATE, 'pendingDeleteConfirmation')
     true
   end
 
@@ -636,7 +639,7 @@ class Domain < ActiveRecord::Base
   def set_graceful_expired
     self.outzone_at = valid_to + Setting.expire_warning_period.days
     self.delete_at = outzone_at + Setting.redemption_grace_period.days
-    statuses << DomainStatus::EXPIRED
+    self.statuses |= [DomainStatus::EXPIRED]
   end
 
   def set_expired

app/models/domain_status.rb

@@ -69,7 +69,7 @@ class DomainStatus < ActiveRecord::Base
   SERVER_ADMIN_CHANGE_PROHIBITED = 'serverAdminChangeProhibited'
   SERVER_TECH_CHANGE_PROHIBITED = 'serverTechChangeProhibited'
   PENDING_DELETE_CONFIRMATION = 'pendingDeleteConfirmation'
-  FORCE_DELETE = 'forceDelete'
+  FORCE_DELETE = 'serverForceDelete'
   DELETE_CANDIDATE = 'deleteCandidate'
   EXPIRED = 'expired'
   RESERVED = 'reserved'
@@ -122,6 +122,7 @@ class DomainStatus < ActiveRecord::Base
 
   class << self
     def admin_statuses
+<<<<<<< HEAD
       [
         SERVER_HOLD,
         # sync with admin_statuses_map
@@ -134,12 +135,31 @@ class DomainStatus < ActiveRecord::Base
         SERVER_UPDATE_PROHIBITED,
         SERVER_DELETE_PROHIBITED
       ]
+=======
+      # [
+      #   SERVER_HOLD,
+      #   # sync with admin_statuses_map
+      #   # SERVER_MANUAL_INZONE,
+      #   # SERVER_RENEW_PROHIBITED,
+      #   # SERVER_TRANSFER_PROHIBITED,
+      #   # SERVER_REGISTRANT_CHANGE_PROHIBITED,
+      #   # SERVER_ADMIN_CHANGE_PROHIBITED,
+      #   # SERVER_TECH_CHANGE_PROHIBITED,
+      #   SERVER_DELETE_PROHIBITED,
+      #   SERVER_UPDATE_PROHIBITED
+      # ]
+      admin_statuses_map.map(&:second)
+>>>>>>> staging
     end
 
+
     def admin_statuses_map
       [
         ['Hold', SERVER_HOLD],
+<<<<<<< HEAD
         # sync with admin_statuses
+=======
+>>>>>>> staging
         ['ManualInzone', SERVER_MANUAL_INZONE],
         # [''],
         ['RenewProhibited', SERVER_RENEW_PROHIBITED],

app/models/epp/domain.rb

@@ -479,6 +479,7 @@ class Epp::Domain < Domain
     user  = ApiUser.find(pending_json['current_user_id'])
     frame = Nokogiri::XML(pending_json['frame'])
     statuses.delete(DomainStatus::PENDING_UPDATE)
+    yield(self) if block_given? # need to skip statuses check here
 
     return unless update(frame, user, false)
     clean_pendings!

app/models/legacy/contact.rb

@@ -3,6 +3,7 @@ module Legacy
     self.table_name = :contact
     belongs_to :object_registry, foreign_key: :id
     belongs_to :object, foreign_key: :id
-    belongs_to :object_state, foreign_key: :id, primary_key: :object_id
+
+    has_one :object_state, -> { where('valid_to IS NULL') }, foreign_key: :object_id
   end
 end

app/models/legacy/dnskey.rb

@@ -1,5 +1,8 @@
 module Legacy
   class Dnskey < Db
     self.table_name = :dnskey
+
+    belongs_to :object_registry, foreign_key: :id
+    belongs_to :object, foreign_key: :id
   end
 end

app/models/legacy/nsset.rb

@@ -2,6 +2,8 @@ module Legacy
   class Nsset < Db
     self.table_name = :nsset
 
+    belongs_to :object, foreign_key: :id
+    belongs_to :object_registry, foreign_key: :id
     has_many :hosts, foreign_key: :nssetid
   end
 end

app/models/legacy/object.rb

@@ -1,6 +1,7 @@
 module Legacy
   class Object < Db
     self.table_name = :object
+    belongs_to :registrar, foreign_key: :upid, primary_key: :legacy_id, class_name: '::Registrar'
 
     def self.instance_method_already_implemented?(method_name)
       return true if method_name == 'update'

app/models/legacy/object_state.rb

@@ -2,40 +2,39 @@ module Legacy
   class ObjectState < Db
     self.table_name = :object_state
 
-    def name
-      # legacy values
-      # 2 => "serverRenewProhibited",
-      # 5 => "serverOutzoneManual",
-      # 6 => "serverInzoneManual",
-      # 7 => "serverBlocked",
-      # 8 => "expirationWarning",
-      # 9 => "expired",
-      # 10 => "unguarded",
-      # 11 => "validationWarning1",
-      # 12 => "validationWarning2",
-      # 13 => "notValidated",
-      # 14 => "nssetMissing",
-      # 15 => "outzone",
-      # 18 => "serverRegistrantChangeProhibited",
-      # 19 => "deleteWarning",
-      # 20 => "outzoneUnguarded",
-      # 1 => "serverDeleteProhibited",
-      # 3 => "serverTransferProhibited",
-      # 4 => "serverUpdateProhibited",
-      # 16 => "linked",
-      # 17 => "deleteCandidate",
-      # 21 => "forceDelete"
+    # legacy values. Just for log
+    # 2 => "serverRenewProhibited",
+    # 5 => "serverOutzoneManual",
+    # 6 => "serverInzoneManual",
+    # 7 => "serverBlocked",
+    # 8 => "expirationWarning",
+    # 9 => "expired",
+    # 10 => "unguarded",
+    # 11 => "validationWarning1",
+    # 12 => "validationWarning2",
+    # 13 => "notValidated",
+    # 14 => "nssetMissing",
+    # 15 => "outzone",
+    # 18 => "serverRegistrantChangeProhibited",
+    # 19 => "deleteWarning",
+    # 20 => "outzoneUnguarded",
+    # 1 => "serverDeleteProhibited",
+    # 3 => "serverTransferProhibited",
+    # 4 => "serverUpdateProhibited",
+    # 16 => "linked",
+    # 17 => "deleteCandidate",
+    # 21 => "forceDelete"
 
-      # new values
-      map = {
+    # new values
+    STATE_NAMES = {
         2 => "serverRenewProhibited",
         5 => "serverHold",
         6 => "serverManualInzone",
-        7 => "serverBlocked",
+        # 7 => "serverBlocked",
         9 => "expired",
-        11 => "validationWarning1",
-        13 => "notValidated",
-        14 => "nssetMissing",
+        # 11 => "validationWarning1",
+        # 13 => "notValidated",
+        14 => "inactive",
         15 => "serverHold",
         18 => "serverRegistrantChangeProhibited",
         1 => "serverDeleteProhibited",
@@ -43,10 +42,12 @@ module Legacy
         4 => "serverUpdateProhibited",
         16 => "linked",
         17 => "deleteCandidate", # grupistaatus
-        21 => "forceDelete" # grupistaatus
-      }
+        21 => "serverForceDelete" # grupistaatus
+    }.freeze
 
-      map[state_id]
+
+    def name
+      STATE_NAMES[state_id]
     end
 
     def desc

app/models/registrar.rb

@@ -51,10 +51,10 @@ class Registrar < ActiveRecord::Base
 
   WHOIS_TRIGGERS = %w(name email phone street city state zip)
 
-  after_save :update_whois_records
+  after_commit :update_whois_records
   def update_whois_records
     return true unless changed? && (changes.keys & WHOIS_TRIGGERS).present?
-    whois_records.map(&:save) # slow currently
+    RegenerateRegistrarWhoisesJob.enqueue id
   end
 
   after_create :create_cash_account

app/models/reserved_domain.rb

@@ -1,5 +1,11 @@
 class ReservedDomain < ActiveRecord::Base
   include Versions # version/reserved_domain_version.rb
+  before_save :fill_empty_passwords
+
+  def fill_empty_passwords
+    return unless names
+    names.each { |k, v| names[k] = SecureRandom.hex if v.blank? }
+  end
 
   class << self
     def pw_for(domain_name)

app/models/whois_record.rb

@@ -1,3 +1,4 @@
+require "erb"
 class WhoisRecord < ActiveRecord::Base
   belongs_to :domain
   belongs_to :registrar
@@ -5,14 +6,6 @@ class WhoisRecord < ActiveRecord::Base
   validates :domain, :name, :body, :json, presence: true
 
   before_validation :populate
-  def populate
-    return if domain_id.blank?
-    self.json = generate_json
-    self.body = generated_body
-    self.name = json['name']
-    self.registrar_id = domain.registrar_id # for faster registrar updates
-  end
-
   after_save :update_whois_server
 
   class << self
@@ -29,6 +22,10 @@ class WhoisRecord < ActiveRecord::Base
     end
   end
 
+  def generated_json
+    @generated_json ||= generate_json
+  end
+
   # rubocop:disable Metrics/MethodLength
   # rubocop:disable Metrics/AbcSize
   def generate_json
@@ -36,116 +33,74 @@ class WhoisRecord < ActiveRecord::Base
     return h if domain.blank?
 
     status_map = {
-      'ok' => 'ok (paid and in zone)'
+        'ok' => 'ok (paid and in zone)'
     }
 
     @disclosed = []
-    h[:name] = domain.name
-    h[:registrant] = domain.registrant.name
-    h[:status] = domain.statuses.map { |x| status_map[x] || x }.join(', ')
+    h[:name]       = domain.name
+    h[:status]     = domain.statuses.map { |x| status_map[x] || x }
     h[:registered] = domain.registered_at.try(:to_s, :iso8601)
-    h[:updated_at] = domain.updated_at.try(:to_s, :iso8601)
-    h[:valid_to] = domain.valid_to.try(:to_s, :iso8601)
+    h[:changed]    = domain.updated_at.try(:to_s, :iso8601)
+    h[:expire]     = domain.valid_to.try(:to_date).try(:to_s)
+    h[:outzone]    = domain.outzone_at.try(:to_date).try(:to_s)
+    h[:delete]     = domain.delete_at.try(:to_date).try(:to_s)
 
-    # update registar triggers when adding new attributes
-    h[:registrar] = domain.registrar.name
-    h[:registrar_phone] = domain.registrar.phone
-    h[:registrar_address] = domain.registrar.address
-    h[:registrar_update_at] = domain.registrar.updated_at.try(:to_s, :iso8601)
+
+    h[:registrant]       = domain.registrant.name
+    h[:registrant_email] = domain.registrant.email
+    h[:changed]          = domain.registrant.updated_at.try(:to_s, :iso8601)
 
     h[:admin_contacts] = []
     domain.admin_contacts.each do |ac|
       @disclosed << [:email, ac.email]
       h[:admin_contacts] << {
-        name: ac.name,
-        email: ac.email,
-        registrar: ac.registrar.name,
-        created_at: ac.created_at.try(:to_s, :iso8601)
+          name: ac.name,
+          email: ac.email,
+          changed: ac.updated_at.try(:to_s, :iso8601)
       }
     end
     h[:tech_contacts] = []
     domain.tech_contacts.each do |tc|
       @disclosed << [:email, tc.email]
       h[:tech_contacts] << {
-        name: tc.name,
-        email: tc.email,
-        registrar: tc.registrar.name,
-        created_at: tc.created_at.try(:to_s, :iso8601)
-      }
-    end
-    h[:nameservers] = []
-    domain.nameservers.each do |ns|
-      h[:nameservers] << {
-        hostname: ns.hostname,
-        updated_at: ns.updated_at.try(:to_s, :iso8601)
+          name: tc.name,
+          email: tc.email,
+          changed: tc.updated_at.try(:to_s, :iso8601)
       }
     end
+
+    # update registar triggers when adding new attributes
+    h[:registrar]         = domain.registrar.name
+    h[:registrar_url]     = domain.registrar.url
+    h[:registrar_phone]   = domain.registrar.phone
+    h[:registrar_address] = domain.registrar.address
+    h[:registrar_changed] = domain.registrar.updated_at.try(:to_s, :iso8601)
+
+    h[:nameservers]         = domain.nameservers.pluck(:hostname).uniq.select(&:present?)
+    h[:nameservers_changed] = domain.nameservers.pluck(:updated_at).max.try(:to_s, :iso8601)
+
+    h[:dnssec_keys]    = domain.dnskeys.map{|key| "#{key.flags} #{key.protocol} #{key.alg} #{key.public_key}" }
+    h[:dnssec_changed] = domain.dnskeys.pluck(:updated_at).max.try(:to_s, :iso8601) rescue nil
+
+
     h[:disclosed] = @disclosed
     h
   end
 
   def generated_body
-    <<-EOS
-Estonia .ee Top Level Domain WHOIS server
-
-Domain:
-  name:       #{json['name']}
-  registrant: #{json['registrant']}
-  status:     #{json['status']}
-  registered: #{Time.zone.parse(json['registered'])}
-  changed:    #{Time.zone.parse(json['updated_at'])}
-  expire:     #{Time.zone.parse(json['valid_to'])}
-  outzone:
-  delete:
-#{contacts_body(json['admin_contacts'], json['tech_contacts'])}
-Registrar:
-  name:       #{json['registrar']}
-  phone:      #{json['registrar_phone']}
-  address:    #{json['registrar_address']}
-  changed:    #{Time.zone.parse(json['registrar_update_at'])}
-#{nameservers_body(json['nameservers'])}
-Estonia .ee Top Level Domain WHOIS server
-More information at http://internet.ee
-    EOS
+    template = Rails.root.join("app/views/for_models/whois.erb".freeze)
+    ERB.new(template.read, nil, "-").result(binding)
   end
   # rubocop:enable Metrics/MethodLength
   # rubocop:enable Metrics/AbcSize
 
-  def contacts_body(admins, techs)
-    admins ||= []
-    techs ||= []
 
-    out = ''
-    out << (admins.size > 1 ? "\nAdministrative contacts" : "\nAdministrative contact")
-    admins.each do |c|
-      out << "\n  name:       #{c['name']}"
-      out << "\n  email:      Not Disclosed - Visit www.internet.ee for webbased WHOIS"
-      out << "\n  registrar:  #{c['registrar']}"
-      out << "\n  created:    #{Time.zone.parse(c['created_at'])}"
-      out << "\n"
-    end
-
-    out << (techs.size > 1 ? "\nTechnical contacts" : "\nTechnical contact:")
-    techs.each do |c|
-      out << "\n  name:       #{c['name']}"
-      out << "\n  email:      Not Disclosed - Visit www.internet.ee for webbased WHOIS"
-      out << "\n  registrar:  #{c['registrar']}"
-      out << "\n  created:    #{Time.zone.parse(c['created_at'])}"
-      out << "\n"
-    end
-    out
-  end
-
-  def nameservers_body(nservers)
-    nservers ||= []
-
-    out = "\nName servers:"
-    nservers.each do |ns|
-      out << "\n  nserver:   #{ns['hostname']}"
-      out << "\n  changed:   #{Time.zone.parse(ns['updated_at'])}"
-      out << "\n"
-    end
-    out
+  def populate
+    return if domain_id.blank?
+    self.json = generated_json
+    self.body = generated_body
+    self.name = json['name']
+    self.registrar_id = domain.registrar_id # for faster registrar updates
   end
 
   def update_whois_server