Merge remote-tracking branch 'origin/master' into 104525318-history_import

# Conflicts:
#	Gemfile
#	app/models/domain.rb

app/models/ability.rb

@@ -16,7 +16,7 @@ class Ability
       @user.roles.each { |role| send(role) } if @user.roles
     when 'ApiUser'
       @user.roles.each { |role| send(role) } if @user.roles
-    when 'RegistrantUser'
+      when 'RegistrantUser'
       static_registrant
     end
 
@@ -117,9 +117,11 @@ class Ability
   end
 
   def static_registrant
+    customer_service
     can :manage, :registrant_domains
     can :manage, :registrant_whois
     can :manage, Depp::Domain
+    can :manage, Domain
   end
 
   def user

app/models/bank_link.rb

@@ -32,7 +32,7 @@ class BankLink
       hash["VK_AMOUNT"]   = number_with_precision(invoice.sum_cache, :precision => 2, :separator => ".")
       hash["VK_CURR"]     = invoice.currency
       hash["VK_REF"]      = ""
-      hash["VK_MSG"]      = "Order nr. #{invoice.number}"
+      hash["VK_MSG"]      = invoice.description
       hash["VK_RETURN"]   = controller.registrar_return_payment_with_url(type)
       hash["VK_CANCEL"]   = controller.registrar_return_payment_with_url(type)
       hash["VK_DATETIME"] = Time.now.strftime("%Y-%m-%dT%H:%M:%S%z")
@@ -101,6 +101,7 @@ class BankLink
         transaction.buyer_iban = params["VK_SND_ACC"]
         transaction.buyer_name = params["VK_SND_NAME"]
         transaction.paid_at    = Time.parse(params["VK_T_DATETIME"])
+        transaction.save!
 
         transaction.autobind_invoice
       end

app/models/bank_transaction.rb

@@ -2,6 +2,7 @@ class BankTransaction < ActiveRecord::Base
   include Versions
   belongs_to :bank_statement
   has_one :account_activity
+  has_many :directo_records, as: :item, class_name: 'Directo'# Deprecated
 
   scope :unbinded, lambda {
     where('id NOT IN (SELECT bank_transaction_id FROM account_activities where bank_transaction_id IS NOT NULL)')
@@ -16,21 +17,32 @@ class BankTransaction < ActiveRecord::Base
     account_activity.invoice
   end
 
+
+  def invoice_num
+    return @invoice_no if defined?(@invoice_no)
+
+    match = description.match(/^[^\d]*(\d+)/)
+    return unless match
+
+    @invoice_no = match[1].try(:to_i)
+  end
+
+  def invoice
+    @invoice ||= registrar.invoices.find_by(number: invoice_num) if registrar
+  end
+
+  def registrar
+    @registrar ||= Registrar.find_by(reference_no: reference_no)
+  end
+
+
   # For successful binding, reference number, invoice id and sum must match with the invoice
   # rubocop: disable Metrics/PerceivedComplexity
   # rubocop: disable Metrics/CyclomaticComplexity
   def autobind_invoice
     return if binded?
-    registrar = Registrar.find_by(reference_no: reference_no)
     return unless registrar
-
-    match = description.match(/^[^\d]*(\d+)/)
-    return unless match
-
-    invoice_no = match[1].to_i
-    return unless invoice_no
-
-    invoice = registrar.invoices.find_by(number: invoice_no)
+    return unless invoice_num
     return unless invoice
 
     return if invoice.binded?

app/models/blocked_domain.rb

@@ -1,5 +1,56 @@
 class BlockedDomain < ActiveRecord::Base
   include Versions
+  before_save :generate_data
+  before_destroy :remove_data
+validates :name, domain_name: true, uniqueness: true
 
-  after_initialize -> { self.names = [] if names.nil? }
+
+  class << self
+    def by_domain name
+      where(name: name)
+    end
+
+    def any_of_domains names
+      where(name: names)
+    end
+  end
+
+  def name= val
+    super SimpleIDN.to_unicode(val)
+  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.save
+  end
+
+  def generate_body
+    template = Rails.root.join("app/views/for_models/whois_other.erb".freeze)
+    ERB.new(template.read, nil, "-").result(binding)
+  end
+
+  def generate_json
+    h = HashWithIndifferentAccess.new
+    h[:name]       = self.name
+    h[:status]     = 'Blocked'
+    h
+  end
+
+  def remove_data
+    return if Domain.where(name: name).any?
+
+    Whois::Record.where(name: name).delete_all
+  end
 end

app/models/business_registry_cache.rb

@@ -0,0 +1,74 @@
+
+=begin
+The portal for registrants has to offer an overview of the domains the user is related to directly or through an organisation.
+Personal relation is defined by matching the personal identification code associated with a domain and the one acquired on
+authentication using electronic ID. Association through a business organisation requires a query to business registry.
+
+  * when user logs in the personal identification code is sent to business registry (using XML service)
+  * business registry returns the list of business registry codes the user is a board member of
+  * the list is cached for two days (configurable)
+  * during that time no new queries are made to business registry for that personal identification code
+    and the cached organisation code listing is used
+  * user sees the listing of domains that are associated with him/her directly or through registered organisation
+  * UI of the portal displays the list of organisation codes and names used to fetch additional domains for the user
+    (currently by clicking on a username in top right corner of the screen).
+    Also time and date of the query to the business registry is displayed with the list of organisations.
+  * if the query to the business registry fails for any reason the list of
+    domains associated directly with the user is still displayed with an error message indicating a problem
+    with receiving current list business entities. Outdated list of organisations cannot be used.
+=end
+
+class BusinessRegistryCache < ActiveRecord::Base
+
+  # 1. load domains by business
+  # 2. load domains by person
+  def associated_domains
+    domains = []
+
+    contact_ids  = Contact.where(ident_type: 'org',  ident: associated_businesses, ident_country_code: 'EE').pluck(:id)
+    contact_ids += Contact.where(ident_type: 'priv', ident: ident, ident_country_code: ident_country_code).pluck(:id)
+
+    unless contact_ids.blank?
+      domains = DomainContact.distinct.where(contact_id: contact_ids).pluck(:domain_id)
+    end
+
+    Domain.includes(:registrar, :registrant).where(id: domains)
+  end
+
+  class << self
+    def fetch_associated_domains(ident_code, ident_cc)
+      fetch_by_ident_and_cc(ident_code, ident_cc).associated_domains
+    end
+
+    def fetch_by_ident_and_cc(ident_code, ident_cc)
+      cache = BusinessRegistryCache.where(ident: ident_code, ident_country_code: ident_cc).first_or_initialize
+      msg_start = "[Ariregister] #{ident_cc}-#{ident_code}:"
+
+      # fetch new data if cache is expired
+      if cache.retrieved_on && cache.retrieved_on > (Time.zone.now - Setting.days_to_keep_business_registry_cache.days)
+        Rails.logger.info("#{msg_start} Info loaded from cache")
+        return cache
+      end
+
+      cache.attributes = business_registry.associated_businesses(ident_code, ident_cc)
+      Rails.logger.info("#{msg_start} Info loaded from server")
+
+      cache.save
+      cache
+    end
+
+    def business_registry
+      Soap::Arireg.new
+    end
+
+    def purge
+      STDOUT << "#{Time.zone.now.utc} - Starting Purge of old BusinessRegistry data from cache\n" unless Rails.env.test?
+      purged = 0
+      BusinessRegistryCache.where('retrieved_on < ?',
+                                  Time.zone.now < Setting.days_to_keep_business_registry_cache.days).each do |br|
+        br.destroy and purged += 1
+      end
+      STDOUT << "#{Time.zone.now.utc} - Finished purging #{purged} old BusinessRegistry cache items\n" unless Rails.env.test?
+    end
+  end
+end

app/models/contact.rb

@@ -29,7 +29,7 @@ class Contact < ActiveRecord::Base
     uniqueness: { message: :epp_id_taken },
     format: { with: /\A[\w\-\:\.\_]*\z/i, message: :invalid },
     length: { maximum: 100, message: :too_long_contact_code }
-  validate :ident_valid_format?
+  validate :val_ident_valid_format?
   validate :uniq_statuses?
   validate :validate_html
 
@@ -58,6 +58,11 @@ class Contact < ActiveRecord::Base
 
   before_save :manage_statuses
   def manage_statuses
+    if domain_transfer # very ugly but need better workflow
+      self.statuses = statuses | [OK, LINKED]
+      return
+    end
+
     manage_linked
     manage_ok
   end
@@ -81,6 +86,7 @@ class Contact < ActiveRecord::Base
   ]
 
   attr_accessor :deliver_emails
+  attr_accessor :domain_transfer # hack but solves problem faster
 
   #
   # STATUSES
@@ -233,13 +239,18 @@ class Contact < ActiveRecord::Base
     name || '[no name]'
   end
 
-  def ident_valid_format?
-    case ident_type
-    when 'priv'
-      case ident_country_code
-      when 'EE'
-        code = Isikukood.new(ident)
-        errors.add(:ident, :invalid_EE_identity_format) unless code.valid?
+  def val_ident_valid_format?
+    case ident_country_code
+    when 'EE'.freeze
+      err_msg = "invalid_EE_identity_format#{"_update" if id}".to_sym
+      case ident_type
+        when 'priv'.freeze
+          errors.add(:ident, err_msg) unless Isikukood.new(ident).valid?
+        when 'org'.freeze
+          # !%w(1 7 8 9).freeze.include?(ident.first) ||
+          if ident.size != 8 || !(ident =~/\A[0-9]{8}\z/)
+            errors.add(:ident, err_msg)
+          end
       end
     end
   end
@@ -492,7 +503,8 @@ class Contact < ActiveRecord::Base
   end
 
  def update_related_whois_records
-   related_domain_descriptions.each{ |x, y| WhoisRecord.find_by(name: x).save}
+   ids = related_domain_descriptions.keys
+   RegenerateWhoisRecordJob.enqueue(ids, :name) if ids.present?
  end	 
 
 end

app/models/depp/domain.rb

@@ -152,23 +152,17 @@ module Depp
            }
         end
 
-        data.css('dsData').each_with_index do |x, i|
-          ds = {
-            ds_key_tag: x.css('keyTag').first.try(:text),
-            ds_alg: x.css('alg').first.try(:text),
-            ds_digest_type: x.css('digestType').first.try(:text),
-            ds_digest: x.css('digest').first.try(:text)
+        data.css('keyData').each_with_index do |x, i|
+          ret[:dnskeys_attributes][i] = {
+              flags: x.css('flags').text,
+              protocol: x.css('protocol').text,
+              alg: x.css('alg').text,
+              public_key: x.css('pubKey').text,
+              ds_key_tag: x.css('keyTag').first.try(:text),
+              ds_alg: x.css('alg').first.try(:text),
+              ds_digest_type: x.css('digestType').first.try(:text),
+              ds_digest: x.css('digest').first.try(:text)
           }
-
-          kd = x.css('keyData').first
-          ds.merge!({
-            flags: kd.css('flags').first.try(:text),
-            protocol: kd.css('protocol').first.try(:text),
-            alg: kd.css('alg').first.try(:text),
-            public_key: kd.css('pubKey').first.try(:text)
-          }) if kd
-
-          ret[:dnskeys_attributes][i] = ds
         end
 
         data.css('status').each_with_index do |x, i|

app/models/directo.rb

@@ -0,0 +1,60 @@
+class Directo < ActiveRecord::Base
+  belongs_to :item, polymorphic: true
+
+  def self.send_receipts
+    new_trans = Invoice.where(invoice_type: "DEB", in_directo: false).where(cancelled_at: nil)
+    total     = new_trans.count
+    counter   = 0
+    Rails.logger.info("[DIRECTO] Will try to send #{total} invoices")
+
+    new_trans.find_in_batches(batch_size: 10).each do |group|
+      mappers = {} # need them as no direct connection between invoice
+      builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+        xml.invoices {
+          group.each do |invoice|
+
+            if invoice.account_activity.nil? || invoice.account_activity.bank_transaction.nil? ||
+                invoice.account_activity.bank_transaction.sum.nil? || invoice.account_activity.bank_transaction.sum != invoice.sum_cache
+              Rails.logger.info("[DIRECTO] Invoice #{invoice.number} has been skipped")
+              next
+            end
+            counter += 1
+
+            num     = invoice.number
+            mappers[num] = invoice
+            xml.invoice(
+                "SalesAgent"  => Setting.directo_sales_agent,
+                "Number"      => num,
+                "InvoiceDate" => invoice.created_at.strftime("%Y-%m-%dT%H:%M:%S"),
+                "PaymentTerm" => Setting.directo_receipt_payment_term,
+                "Currency"    => invoice.currency,
+                "CustomerCode"=> invoice.buyer.try(:directo_handle)
+            ){
+              xml.line(
+                  "ProductID"      => Setting.directo_receipt_product_name,
+                  "Quantity"       => 1,
+                  "UnitPriceWoVAT" => ActionController::Base.helpers.number_with_precision(invoice.sum_cache/(1+invoice.vat_prc), precision: 2, separator: "."),
+                  "ProductName"    => invoice.description
+              )
+            }
+          end
+        }
+      end
+
+      data = builder.to_xml.gsub("\n",'')
+      response = RestClient::Request.execute(url: ENV['directo_invoice_url'], method: :post, payload: {put: "1", what: "invoice", xmldata: data}, verify_ssl: false).to_s
+      dump_result_to_db(mappers, response)
+    end
+
+    STDOUT << "#{Time.zone.now.utc} - Directo receipts sending finished. #{counter} of #{total} are sent\n"
+  end
+
+  def self.dump_result_to_db mappers, xml
+    Nokogiri::XML(xml).css("Result").each do |res|
+      obj = mappers[res.attributes["docid"].value.to_i]
+      obj.directo_records.create!(response: res.as_json.to_h)
+      obj.update_columns(in_directo: true)
+      Rails.logger.info("[DIRECTO] Invoice #{res.attributes["docid"].value} was pushed and return is #{res.as_json.to_h.inspect}")
+    end
+  end
+end

app/models/domain.rb

@@ -93,7 +93,7 @@ class Domain < ActiveRecord::Base
   def update_reserved_domains
     return unless in_reserved_list?
     rd = ReservedDomain.by_domain(name).first
-    rd.names[name] = SecureRandom.hex
+    rd.password = SecureRandom.hex
     rd.save
   end
 
@@ -203,6 +203,31 @@ class Domain < ActiveRecord::Base
     statuses.include? DomainStatus::SERVER_TECH_CHANGE_PROHIBITED
   end
 
+  def self.clean_expired_pendings
+    ActiveSupport::Deprecation.instance.deprecation_warning(DomainCron, __method__)
+    DomainCron.send(__method__)
+  end
+
+  def self.start_expire_period
+    ActiveSupport::Deprecation.instance.deprecation_warning(DomainCron, __method__)
+    DomainCron.send(__method__)
+  end
+
+  def self.start_redemption_grace_period
+    ActiveSupport::Deprecation.instance.deprecation_warning(DomainCron, __method__)
+    DomainCron.send(__method__)
+  end
+
+  def self.start_delete_period
+    ActiveSupport::Deprecation.instance.deprecation_warning(DomainCron, __method__)
+    DomainCron.send(__method__)
+  end
+
+  def self.destroy_delete_candidates
+    ActiveSupport::Deprecation.instance.deprecation_warning(DomainCron, __method__)
+    DomainCron.send(__method__)
+  end
+
   class << self
     def convert_period_to_time(period, unit)
       return (period.to_i / 365).years if unit == 'd'
@@ -220,126 +245,9 @@ class Domain < ActiveRecord::Base
         { admin_contacts: :registrar }
       )
     end
-
     def next_id
       self.connection.select_value("SELECT nextval('#{self.sequence_name}')")
     end
-
-    # rubocop: disable Metrics/AbcSize
-    # rubocop: disable Metrics/CyclomaticComplexity
-    # rubocop: disable Metrics/PerceivedComplexity
-    def clean_expired_pendings
-      STDOUT << "#{Time.zone.now.utc} - Clean expired domain pendings\n" unless Rails.env.test?
-
-      expire_at = Setting.expire_pending_confirmation.hours.ago
-      count = 0
-      expired_pending_domains = Domain.where('registrant_verification_asked_at <= ?', expire_at)
-      expired_pending_domains.each do |domain|
-        unless domain.pending_update? || domain.pending_delete? || domain.pending_delete_confirmation?
-          msg = "#{Time.zone.now.utc} - ISSUE: DOMAIN #{domain.id}: #{domain.name} IS IN EXPIRED PENDING LIST, " \
-                "but no pendingDelete/pendingUpdate state present!\n"
-          STDOUT << msg unless Rails.env.test?
-          next
-        end
-        count += 1
-        if domain.pending_update?
-          DomainMailer.pending_update_expired_notification_for_new_registrant(domain.id).deliver
-        end
-        if domain.pending_delete? || domain.pending_delete_confirmation?
-          DomainMailer.pending_delete_expired_notification(domain.id, true).deliver
-        end
-        domain.clean_pendings!
-        unless Rails.env.test?
-          STDOUT << "#{Time.zone.now.utc} Domain.clean_expired_pendings: ##{domain.id} (#{domain.name})\n"
-        end
-      end
-      STDOUT << "#{Time.zone.now.utc} - Successfully cancelled #{count} domain pendings\n" unless Rails.env.test?
-      count
-    end
-    # rubocop: enable Metrics/PerceivedComplexity
-    # rubocop: enable Metrics/AbcSize
-    # rubocop: enable Metrics/CyclomaticComplexity
-
-    # rubocop: disable Metrics/LineLength
-    def start_expire_period
-      STDOUT << "#{Time.zone.now.utc} - Expiring domains\n" unless Rails.env.test?
-
-      domains = Domain.where('valid_to <= ?', Time.zone.now)
-      domains.each do |domain|
-        next unless domain.expirable?
-        domain.set_graceful_expired
-        DomainMailer.expiration_reminder(domain.id).deliver
-        STDOUT << "#{Time.zone.now.utc} Domain.start_expire_period: ##{domain.id} (#{domain.name}) #{domain.changes}\n" unless Rails.env.test?
-        domain.save
-      end
-
-      STDOUT << "#{Time.zone.now.utc} - Successfully expired #{domains.count} domains\n" unless Rails.env.test?
-    end
-
-    def start_redemption_grace_period
-      STDOUT << "#{Time.zone.now.utc} - Setting server_hold to domains\n" unless Rails.env.test?
-
-      d = Domain.where('outzone_at <= ?', Time.zone.now)
-      d.each do |domain|
-        next unless domain.server_holdable?
-        domain.statuses << DomainStatus::SERVER_HOLD
-        STDOUT << "#{Time.zone.now.utc} Domain.start_redemption_grace_period: ##{domain.id} (#{domain.name}) #{domain.changes}\n" unless Rails.env.test?
-        domain.save
-      end
-
-      STDOUT << "#{Time.zone.now.utc} - Successfully set server_hold to #{d.count} domains\n" unless Rails.env.test?
-    end
-
-    def start_delete_period
-      STDOUT << "#{Time.zone.now.utc} - Setting delete_candidate to domains\n" unless Rails.env.test?
-
-      d = Domain.where('delete_at <= ?', Time.zone.now)
-      d.each do |domain|
-        next unless domain.delete_candidateable?
-        domain.statuses << DomainStatus::DELETE_CANDIDATE
-        STDOUT << "#{Time.zone.now.utc} Domain.start_delete_period: ##{domain.id} (#{domain.name}) #{domain.changes}\n" unless Rails.env.test?
-        domain.save
-      end
-
-      return if Rails.env.test?
-      STDOUT << "#{Time.zone.now.utc} - Successfully set delete_candidate to #{d.count} domains\n"
-    end
-
-    # rubocop:disable Rails/FindEach
-    # rubocop:disable Metrics/AbcSize
-    def destroy_delete_candidates
-      STDOUT << "#{Time.zone.now.utc} - Destroying domains\n" unless Rails.env.test?
-
-      c = 0
-      Domain.where("statuses @> '{deleteCandidate}'::varchar[]").each do |x|
-        Whois::Record.where('domain_id = ?', x.id).try(':destroy')
-        destroy_with_message x
-        STDOUT << "#{Time.zone.now.utc} Domain.destroy_delete_candidates: by deleteCandidate ##{x.id} (#{x.name})\n" unless Rails.env.test?
-
-        c += 1
-      end
-
-      Domain.where('force_delete_at <= ?', Time.zone.now).each do |x|
-        Whois::Record.where('domain_id = ?', x.id).try(':destroy')
-        destroy_with_message x
-        STDOUT << "#{Time.zone.now.utc} Domain.destroy_delete_candidates: by force delete time ##{x.id} (#{x.name})\n" unless Rails.env.test?
-        c += 1
-      end
-
-      STDOUT << "#{Time.zone.now.utc} - Successfully destroyed #{c} domains\n" unless Rails.env.test?
-    end
-    # rubocop: enable Metrics/AbcSize
-    # rubocop:enable Rails/FindEach
-    # rubocop: enable Metrics/LineLength
-    def destroy_with_message(domain)
-      domain.destroy
-      bye_bye = domain.versions.last
-      domain.registrar.messages.create!(
-          body: "#{I18n.t(:domain_deleted)}: #{domain.name}",
-          attached_obj_id: bye_bye.id,
-          attached_obj_type: bye_bye.class.to_s # DomainVersion
-      )
-    end
   end
 
   def name=(value)
@@ -412,8 +320,7 @@ class Domain < ActiveRecord::Base
       end
     end
 
-    return false if statuses.include_any?(DomainStatus::DELETE_CANDIDATE, DomainStatus::SERVER_RENEW_PROHIBITED,
-                                          DomainStatus::CLIENT_RENEW_PROHIBITED, DomainStatus::PENDING_RENEW,
+    return false if statuses.include_any?(DomainStatus::DELETE_CANDIDATE, DomainStatus::PENDING_RENEW,
                                           DomainStatus::PENDING_TRANSFER, DomainStatus::PENDING_DELETE,
                                           DomainStatus::PENDING_UPDATE, DomainStatus::PENDING_DELETE_CONFIRMATION)
     true
@@ -443,8 +350,26 @@ class Domain < ActiveRecord::Base
     save
   end
 
+
+  # state change shouln't be
+  def clean_pendings_lowlevel
+    statuses.delete(DomainStatus::PENDING_DELETE_CONFIRMATION)
+    statuses.delete(DomainStatus::PENDING_UPDATE)
+    statuses.delete(DomainStatus::PENDING_DELETE)
+
+    status_notes[DomainStatus::PENDING_UPDATE] = ''
+    status_notes[DomainStatus::PENDING_DELETE] = ''
+
+    update_columns(
+        registrant_verification_token:    nil,
+        registrant_verification_asked_at: nil,
+        pending_json: {},
+        status_notes: status_notes,
+        statuses:     statuses.presence || [DomainStatus::OK]
+    )
+  end
+
   def pending_update!
-    old_registrant_id = registrant_id
     return true if pending_update?
     self.epp_pending_update = true # for epp
 
@@ -456,8 +381,8 @@ class Domain < ActiveRecord::Base
     new_registrant_email = registrant.email
     new_registrant_name  = registrant.name
 
-    DomainMailer.pending_update_request_for_old_registrant(id, old_registrant_id, deliver_emails).deliver
-    DomainMailer.pending_update_notification_for_new_registrant(id, old_registrant_id, deliver_emails).deliver
+    send_mail :pending_update_request_for_old_registrant
+    send_mail :pending_update_notification_for_new_registrant
 
     reload # revert back to original
 
@@ -549,7 +474,7 @@ class Domain < ActiveRecord::Base
 
   def validate_nameserver_ips
     nameservers.to_a.reject(&:marked_for_destruction?).each do |ns|
-      next unless ns.hostname.end_with?(name)
+      next unless ns.hostname.end_with?(".#{name}")
       next if ns.ipv4.present?
       errors.add(:nameservers, :invalid) if errors[:nameservers].blank?
       ns.errors.add(:ipv4, :blank)
@@ -579,7 +504,7 @@ class Domain < ActiveRecord::Base
 
   def name_in_wire_format
     res = ''
-    parts = name.split('.')
+    parts = name_puny.split('.')
     parts.each do |x|
       res += format('%02X', x.length) # length of label in hex
       res += x.each_byte.map { |b| format('%02X', b) }.join # label
@@ -715,8 +640,12 @@ class Domain < ActiveRecord::Base
         case s
           when DomainStatus::PENDING_DELETE
             self.delete_at = nil
-          # Handle any other special remove cases?
-          # when DomainStatus::FORCE_DELETE unset_force_delete
+          when DomainStatus::SERVER_MANUAL_INZONE # removal causes server hold to set
+            self.outzone_at = Time.zone.now if self.force_delete_at.present?
+          when DomainStatus::DomainStatus::EXPIRED # removal causes server hold to set
+            self.outzone_at = self.valid_to + 15.day
+          when DomainStatus::DomainStatus::SERVER_HOLD # removal causes server hold to set
+            self.outzone_at = nil
         end
       end
     end
@@ -823,5 +752,24 @@ class Domain < ActiveRecord::Base
       status_notes[status] = notes[i]
     end
   end
+
+  def send_mail(action)
+    DomainMailer.send(action, DomainMailModel.new(self).send(action)).deliver
+  end
+
+
+  def self.to_csv
+    CSV.generate do |csv|
+      csv << column_names
+      all.each do |domain|
+        csv << domain.attributes.values_at(*column_names)
+      end
+    end
+  end
+
+  def self.pdf(html)
+    kit = PDFKit.new(html)
+    kit.to_pdf
+  end
 end
 # rubocop: enable Metrics/ClassLength

app/models/domain_cron.rb

@@ -0,0 +1,122 @@
+class DomainCron
+
+  def self.clean_expired_pendings
+    STDOUT << "#{Time.zone.now.utc} - Clean expired domain pendings\n" unless Rails.env.test?
+
+    expire_at = Setting.expire_pending_confirmation.hours.ago
+    count = 0
+    expired_pending_domains = Domain.where('registrant_verification_asked_at <= ?', expire_at)
+    expired_pending_domains.each do |domain|
+      unless domain.pending_update? || domain.pending_delete? || domain.pending_delete_confirmation?
+        msg = "#{Time.zone.now.utc} - ISSUE: DOMAIN #{domain.id}: #{domain.name} IS IN EXPIRED PENDING LIST, " \
+                "but no pendingDelete/pendingUpdate state present!\n"
+        STDOUT << msg unless Rails.env.test?
+        next
+      end
+      count += 1
+      if domain.pending_update?
+        DomainMailer.pending_update_expired_notification_for_new_registrant(domain.id).deliver
+      end
+      if domain.pending_delete? || domain.pending_delete_confirmation?
+        DomainMailer.pending_delete_expired_notification(domain.id, deliver_emails).deliver
+      end
+      domain.clean_pendings_lowlevel
+      unless Rails.env.test?
+        STDOUT << "#{Time.zone.now.utc} DomainCron.clean_expired_pendings: ##{domain.id} (#{domain.name})\n"
+      end
+    end
+    STDOUT << "#{Time.zone.now.utc} - Successfully cancelled #{count} domain pendings\n" unless Rails.env.test?
+    count
+  end
+
+  def self.start_expire_period
+    STDOUT << "#{Time.zone.now.utc} - Expiring domains\n" unless Rails.env.test?
+
+    domains = Domain.where('valid_to <= ?', Time.zone.now)
+    marked = 0
+    real = 0
+    domains.each do |domain|
+      next unless domain.expirable?
+      real += 1
+      domain.set_graceful_expired
+      STDOUT << "#{Time.zone.now.utc} DomainCron.start_expire_period: ##{domain.id} (#{domain.name}) #{domain.changes}\n" unless Rails.env.test?
+      domain.save(validate: false) and marked += 1
+    end
+
+    STDOUT << "#{Time.zone.now.utc} - Successfully expired #{marked} of #{real} domains\n" unless Rails.env.test?
+  end
+
+  def self.start_redemption_grace_period
+    STDOUT << "#{Time.zone.now.utc} - Setting server_hold to domains\n" unless Rails.env.test?
+
+    d = Domain.where('outzone_at <= ?', Time.zone.now)
+    marked = 0
+    real = 0
+    d.each do |domain|
+      next unless domain.server_holdable?
+      real += 1
+      domain.statuses << DomainStatus::SERVER_HOLD
+      STDOUT << "#{Time.zone.now.utc} DomainCron.start_redemption_grace_period: ##{domain.id} (#{domain.name}) #{domain.changes}\n" unless Rails.env.test?
+      domain.save(validate: false) and marked += 1
+    end
+
+    STDOUT << "#{Time.zone.now.utc} - Successfully set server_hold to #{marked} of #{real} domains\n" unless Rails.env.test?
+    marked
+  end
+
+  def self.start_delete_period
+    begin
+      STDOUT << "#{Time.zone.now.utc} - Setting delete_candidate to domains\n" unless Rails.env.test?
+
+      d = Domain.where('delete_at <= ?', Time.zone.now)
+      marked = 0
+      real = 0
+      d.each do |domain|
+        next unless domain.delete_candidateable?
+        real += 1
+        domain.statuses << DomainStatus::DELETE_CANDIDATE
+        STDOUT << "#{Time.zone.now.utc} DomainCron.start_delete_period: ##{domain.id} (#{domain.name}) #{domain.changes}\n" unless Rails.env.test?
+        domain.save(validate: false) and marked += 1
+      end
+    ensure # the operator should see what was accomplished
+      STDOUT << "#{Time.zone.now.utc} - Finished setting delete_candidate -  #{marked} out of #{real} successfully set\n" unless Rails.env.test?
+    end
+    marked
+  end
+
+  def self.destroy_delete_candidates
+    STDOUT << "#{Time.zone.now.utc} - Destroying domains\n" unless Rails.env.test?
+
+    c = 0
+    Domain.where("statuses @> '{deleteCandidate}'::varchar[]").each do |x|
+      WhoisRecord.where(domain_id: x.id).destroy_all
+      destroy_with_message x
+      STDOUT << "#{Time.zone.now.utc} Domain.destroy_delete_candidates: by deleteCandidate ##{x.id} (#{x.name})\n" unless Rails.env.test?
+
+      c += 1
+    end
+
+    Domain.where('force_delete_at <= ?', Time.zone.now).each do |x|
+      WhoisRecord.where(domain_id: x.id).destroy_all
+      destroy_with_message x
+      STDOUT << "#{Time.zone.now.utc} DomainCron.destroy_delete_candidates: by force delete time ##{x.id} (#{x.name})\n" unless Rails.env.test?
+      c += 1
+    end
+
+    STDOUT << "#{Time.zone.now.utc} - Successfully destroyed #{c} domains\n" unless Rails.env.test?
+  end
+
+  # rubocop: enable Metrics/AbcSize
+  # rubocop:enable Rails/FindEach
+  # rubocop: enable Metrics/LineLength
+  def self.destroy_with_message(domain)
+    domain.destroy
+    bye_bye = domain.versions.last
+    domain.registrar.messages.create!(
+        body: "#{I18n.t(:domain_deleted)}: #{domain.name}",
+        attached_obj_id: bye_bye.id,
+        attached_obj_type: bye_bye.class.to_s # DomainVersion
+    )
+  end
+
+end

app/models/domain_mail_model.rb

@@ -0,0 +1,180 @@
+class DomainMailModel
+  # Capture current values used in app/views/mailers/domain_mailer/* and app/mailers/domain_mailer will send later
+  
+  def initialize(domain)
+    @domain = domain
+    @params = {errors: [], deliver_emails: domain.deliver_emails, id: domain.id}
+  end
+
+  def pending_update_request_for_old_registrant
+    registrant_old
+    subject(:pending_update_request_for_old_registrant_subject)
+    confirm_update
+    domain_info
+    compose
+  end
+
+  def pending_update_notification_for_new_registrant
+    registrant     # new registrant at this point 
+    subject(:pending_update_notification_for_new_registrant_subject)
+    domain_info
+    compose
+  end
+      
+  def registrant_updated_notification_for_new_registrant
+    registrant
+    subject(:registrant_updated_notification_for_new_registrant_subject)
+    domain_info
+    compose
+  end
+
+  def registrant_updated_notification_for_old_registrant
+    registrant_pending
+    registrant_old
+    subject(:registrant_updated_notification_for_old_registrant_subject)
+    new_registrant = Registrant.find @domain.pending_json['new_registrant_id']
+    @params[:registrant_name] = new_registrant.name
+    @params[:registrant_ident] = new_registrant.ident
+    @params[:registrant_priv] = new_registrant.priv?
+    @params[:registrant_email] = new_registrant.email
+    @params[:registrant_street] = new_registrant.street
+    @params[:registrant_city] = new_registrant.city
+    @params[:registrant_country] = new_registrant.country.name
+    compose
+  end
+  
+  def pending_update_rejected_notification_for_new_registrant
+    registrant_pending
+    subject(:pending_update_rejected_notification_for_new_registrant_subject)
+    @params[:deliver_emails] = true # triggered from que
+    @params[:registrar_name] = @domain.registrar.name
+    compose
+  end
+
+  def pending_update_expired_notification_for_new_registrant
+    registrant_pending
+    subject(:pending_update_expired_notification_for_new_registrant_subject)
+    domain_info
+    compose
+  end
+
+  def pending_deleted
+    registrant
+    subject(:domain_pending_deleted_subject)
+    confirm_delete
+    compose
+  end
+
+  def pending_delete_rejected_notification
+    registrant
+    subject(:pending_delete_rejected_notification_subject)
+    compose
+  end
+
+  def pending_delete_expired_notification
+    registrant
+    subject(:pending_delete_expired_notification_subject)
+    compose
+  end
+
+  def delete_confirmation
+    registrant
+    subject(:delete_confirmation_subject)
+    compose
+  end
+
+  def force_delete
+    admins
+    subject(:force_delete_subject)
+    compose
+  end
+
+  private
+  
+  def registrant_old
+    @params[:recipient] = format Registrant.find(@domain.registrant_id_was).email
+  end
+      
+  def registrant
+    @params[:recipient] = format @domain.registrant.email
+  end
+
+  def registrant_pending
+    @params[:recipient] = format @domain.pending_json['new_registrant_email']
+    @params[:new_registrant_name] = @domain.pending_json['new_registrant_name']
+    @params[:old_registrant_name] = @domain.registrant.name
+  end
+  
+  # registrant and domain admin contacts
+  def admins
+    emails = ([@domain.registrant.email] + @domain.admin_contacts.map { |x| format(x.email) })
+    @params[:recipient] = emails.uniq.map { |x| format(x) }
+  end
+
+  # puny internet domain name, TODO: username<email>
+  def format(email)
+    return warn_no_email if email.nil?
+    user, host = email.split('@')
+    host = SimpleIDN.to_ascii(host)
+    "#{user}@#{host}"
+  end
+
+  def subject(subject)
+    @params[:name] = @domain.name
+    @params[:subject] = "#{I18n.t(subject, name: @domain.name)}, [#{@domain.name}]"
+  end
+
+  def confirm_update
+    verification_url('domain_update_confirms')
+  end
+  
+  def confirm_delete
+    verification_url('domain_delete_confirms')
+  end
+
+  def compose
+    @params
+  end
+  
+  def verification_url(path)
+    token = verification_token or return
+    @params[:verification_url] = "#{ENV['registrant_url']}/registrant/#{path}/#{@domain.id}?token=#{token}"
+  end
+  
+  def verification_token
+    return warn_missing(:registrant_verification_token) if @domain.registrant_verification_token.blank?
+    return warn_missing(:registrant_verification_asked_at) if @domain.registrant_verification_asked_at.blank?
+    @domain.registrant_verification_token
+  end
+  
+  def domain_info
+    [:name, :registrar_name,
+     :registrant_name, :registrant_ident, :registrant_email,
+     :registrant_street,:registrant_city
+    ].each do |attr|
+      @params.store attr, @domain.send(attr)
+    end
+    @params.store :registrant_country, @domain.registrant_country.name
+    @params.store :registrant_priv, @domain.registrant.priv?
+    @params.store :old_registrant_name, Registrant.find(@domain.registrant_id_was).name
+    @params
+  end
+
+  def warn_no_email(item = 'email')
+    warn_missing item
+    nil
+  end
+      
+  def warn_missing(item)
+    warn_not_delivered "#{item.to_s} is missing for #{@domain.name}"
+  end
+
+  def warn_not_delivered(reason)
+    message = "EMAIL NOT DELIVERED: #{reason}"
+    @params[:errors] << message
+#    Rails.logger.warn message
+    nil
+  end
+  
+end
+

app/models/epp/contact.rb

@@ -123,6 +123,7 @@ class Epp::Contact < Contact
         [:email, :invalid],
         [:ident, :invalid],
         [:ident, :invalid_EE_identity_format],
+        [:ident, :invalid_EE_identity_format_update],
         [:ident, :invalid_birthday_format],
         [:ident, :invalid_country_code],
         [:ident_type, :missing],
@@ -160,20 +161,20 @@ class Epp::Contact < Contact
       self.ident_updated_at ||= Time.zone.now # not in use
       ident_frame = frame.css('ident').first
 
-      if ident_frame && ident_attr_valid?(ident_frame) && ident_country_code.blank? && ident_type.in?(%w(org priv).freeze)
-        at.merge!(ident_country_code: ident_frame.attr('cc'))
+      if ident_frame && ident_attr_valid?(ident_frame)
+        org_priv = %w(org priv).freeze
+        if ident_country_code.blank? && org_priv.include?(ident_type) && org_priv.include?(ident_frame.attr('type'))
+          at.merge!(ident_country_code: ident_frame.attr('cc'), ident_type: ident_frame.attr('type'))
+        elsif ident_type == "birthday" && !ident[/\A\d{4}-\d{2}-\d{2}\z/] && (Date.parse(ident) rescue false)
+          at.merge!(ident: ident_frame.text)
+          at.merge!(ident_country_code: ident_frame.attr('cc')) if ident_frame.attr('cc').present?
+        elsif ident_type.blank? && ident_country_code.blank?
+          at.merge!(ident_type: ident_frame.attr('type'))
+          at.merge!(ident_country_code: ident_frame.attr('cc')) if ident_frame.attr('cc').present?
+        else
+          throw :epp_error, {code: '2306', msg: I18n.t(:ident_update_error)}
+        end
       end
-
-      # Deprecated
-      # if ident_updated_at.present?
-      #   throw :epp_error, {
-      #     code: '2306',
-      #     msg: I18n.t(:ident_update_error)
-      #   }
-      # else
-      #   at.merge!(self.class.ident_attrs(frame.css('ident').first))
-      #   self.ident_updated_at = Time.zone.now
-      # end
     end
 
     super(at)

app/models/epp/domain.rb

@@ -3,10 +3,12 @@ class Epp::Domain < Domain
   include EppErrors
 
   # TODO: remove this spagetti once data in production is correct.
-  attr_accessor :is_renewal
+  attr_accessor :is_renewal, :is_transfer
 
   before_validation :manage_permissions
   def manage_permissions
+    return if is_admin # this bad hack for 109086524, refactor later
+    return true if is_transfer || is_renewal
     return unless update_prohibited? || delete_prohibited?
     add_epp_error('2304', nil, nil, I18n.t(:object_status_prohibits_operation))
     false
@@ -14,7 +16,7 @@ class Epp::Domain < Domain
 
   after_validation :validate_contacts
   def validate_contacts
-    return true if is_renewal
+    return true if is_renewal || is_transfer
 
     ok = true
     active_admins = admin_domain_contacts.select { |x| !x.marked_for_destruction? }
@@ -486,6 +488,15 @@ class Epp::Domain < Domain
 
     # at[:statuses] += at_add[:domain_statuses_attributes]
 
+    if registrant_id && registrant.code == frame.css('registrant')
+
+      throw :epp_error, {
+        code: '2305',
+        msg: I18n.t(:contact_already_associated_with_the_domain)
+      }
+
+    end
+
     if errors.empty? && verify &&
        Setting.request_confrimation_on_registrant_change_enabled &&
        frame.css('registrant').present? &&
@@ -500,20 +511,22 @@ class Epp::Domain < Domain
   # rubocop: enable Metrics/CyclomaticComplexity
 
   def apply_pending_update!
-    old_registrant_email = DomainMailer.registrant_updated_notification_for_old_registrant(id, deliver_emails)
     preclean_pendings
     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
-    self.save
 
+    self.deliver_emails = true # turn on email delivery
+    self.statuses.delete(DomainStatus::PENDING_UPDATE)
     ::PaperTrail.whodunnit = user.id_role_username # updator str should be the request originator not the approval user
+
+    send_mail :registrant_updated_notification_for_old_registrant
     return unless update(frame, user, false)
     clean_pendings!
-    self.deliver_emails = true # turn on email delivery
-    DomainMailer.registrant_updated_notification_for_new_registrant(id, deliver_emails).deliver
-    old_registrant_email.deliver
+
+    send_mail :registrant_updated_notification_for_new_registrant
+    WhoisRecord.find_by(domain_id: id).save # need to reload model
+
+    save! # for notification if everything fails
     true
   end
 
@@ -586,6 +599,7 @@ class Epp::Domain < Domain
 
     statuses.delete(DomainStatus::SERVER_HOLD)
     statuses.delete(DomainStatus::EXPIRED)
+    statuses.delete(DomainStatus::SERVER_UPDATE_PROHIBITED)
 
     save
   end
@@ -594,6 +608,8 @@ class Epp::Domain < Domain
 
   # rubocop: disable Metrics/CyclomaticComplexity
   def transfer(frame, action, current_user)
+    @is_transfer = true
+
     case action
     when 'query'
       return domain_transfers.last if domain_transfers.any?
@@ -621,6 +637,7 @@ class Epp::Domain < Domain
     oc.registrar_id = registrar_id
     oc.copy_from_id = c.id
     oc.prefix_code
+    oc.domain_transfer = true
     oc.save!(validate: false)
     oc
   end

app/models/invoice.rb

@@ -2,14 +2,27 @@ class Invoice < ActiveRecord::Base
   include Versions
   belongs_to :seller, class_name: 'Registrar'
   belongs_to :buyer, class_name: 'Registrar'
+  has_one  :account_activity
   has_many :invoice_items
-  has_one :account_activity
+  has_many :directo_records, as: :item, class_name: 'Directo'
 
   accepts_nested_attributes_for :invoice_items
 
   scope :unbinded, lambda {
     where('id NOT IN (SELECT invoice_id FROM account_activities where invoice_id IS NOT NULL)')
   }
+  scope :all_columns,                    ->{select("invoices.*")}
+  scope :sort_due_date_column,           ->{all_columns.select("CASE WHEN invoices.cancelled_at is not null THEN
+                                                                (invoices.cancelled_at + interval '100 year') ELSE
+                                                                 invoices.due_date END AS sort_due_date")}
+  scope :sort_by_sort_due_date_asc,      ->{sort_due_date_column.order("sort_due_date ASC")}
+  scope :sort_by_sort_due_date_desc,     ->{sort_due_date_column.order("sort_due_date DESC")}
+  scope :sort_receipt_date_column,       ->{all_columns.includes(:account_activity).references(:account_activity).select(%Q{
+                                            CASE WHEN account_activities.created_at is not null THEN account_activities.created_at
+                                            WHEN invoices.cancelled_at is not null THEN invoices.cancelled_at + interval '100 year'
+                                            ELSE NULL END AS sort_receipt_date })}
+  scope :sort_by_sort_receipt_date_asc,  ->{sort_receipt_date_column.order("sort_receipt_date ASC")}
+  scope :sort_by_sort_receipt_date_desc, ->{sort_receipt_date_column.order("sort_receipt_date DESC")}
 
   attr_accessor :billing_email
   validates :billing_email, email_format: { message: :invalid }, allow_blank: true
@@ -17,7 +30,10 @@ class Invoice < ActiveRecord::Base
   validates :invoice_type, :due_date, :currency, :seller_name,
             :seller_iban, :buyer_name, :invoice_items, :vat_prc, presence: true
 
-  before_create :set_invoice_number
+  before_create :set_invoice_number, :check_vat
+
+  before_save   :check_vat
+
   def set_invoice_number
     last_no = Invoice.order(number: :desc).where('number IS NOT NULL').limit(1).pluck(:number).first
 
@@ -34,6 +50,12 @@ class Invoice < ActiveRecord::Base
     false
   end
 
+  def check_vat
+    if buyer.country_code != 'EE' && buyer.vat_no.present?
+      self.vat_prc = 0
+    end
+  end
+
   before_save -> { self.sum_cache = sum }
 
   class << self
@@ -90,6 +112,10 @@ class Invoice < ActiveRecord::Base
     kit.to_pdf
   end
 
+  def description
+    "Order nr. #{number}"
+  end
+
   def pdf_name
     "invoice-#{number}.pdf"
   end

app/models/pricelist.rb

@@ -31,7 +31,7 @@ class Pricelist < ActiveRecord::Base
     def pricelist_for(zone, operation, period)
       lists = valid.where(category: zone, operation_category: operation, duration: period)
       return lists.first if lists.count == 1
-      lists.where('valid_to IS NOT NULL').order(valid_from: :desc).first
+      lists.order(valid_from: :desc).first
     end
   end
 end

app/models/registrant_user.rb

@@ -1,4 +1,5 @@
 class RegistrantUser < User
+  ACCEPTED_ISSUER = 'AS Sertifitseerimiskeskus'
   attr_accessor :idc_data
 
   def ability
@@ -6,6 +7,19 @@ class RegistrantUser < User
   end
   delegate :can?, :cannot?, to: :ability
 
+  def ident
+    registrant_ident.to_s.split("-").last
+  end
+
+  def domains
+    ident_cc, ident = registrant_ident.to_s.split '-'
+    Domain.includes(:registrar, :registrant).where(contacts: {
+                                                       ident_type: 'priv',
+                                                       ident: ident, #identity_code,
+                                                       ident_country_code: ident_cc #country_code
+                                                   })
+  end
+
   def to_s
     username
   end
@@ -13,11 +27,9 @@ class RegistrantUser < User
   class << self
     def find_or_create_by_idc_data(idc_data, issuer_organization)
       return false if idc_data.blank?
-      return false if issuer_organization != 'AS Sertifitseerimiskeskus'
+      return false if issuer_organization != ACCEPTED_ISSUER
 
       idc_data.force_encoding('UTF-8')
-      logger.error(idc_data)
-      logger.error(idc_data.encoding)
       identity_code = idc_data.scan(/serialNumber=(\d+)/).flatten.first
       country = idc_data.scan(/^\/C=(.{2})/).flatten.first
       first_name = idc_data.scan(%r{/GN=(.+)/serialNumber}).flatten.first

app/models/registrant_verification.rb

@@ -12,7 +12,6 @@ class RegistrantVerification < ActiveRecord::Base
   belongs_to :domain
 
   validates :verification_token, :domain_name, :domain, :action, :action_type, presence: true
-  validates :domain, uniqueness: { scope: [:domain_id, :verification_token] }
 
   def domain_registrant_change_confirm!
     self.action_type = DOMAIN_REGISTRANT_CHANGE
@@ -23,7 +22,7 @@ class RegistrantVerification < ActiveRecord::Base
   def domain_registrant_change_reject!
     self.action_type = DOMAIN_REGISTRANT_CHANGE
     self.action = REJECTED
-    DomainUpdateConfirmJob.enqueue domain.id, REJECTED if save
+    DomainUpdateConfirmJob.run domain.id, REJECTED if save
   end
 
   def domain_registrant_delete_confirm!

app/models/reserved_domain.rb

@@ -1,25 +1,75 @@
 class ReservedDomain < ActiveRecord::Base
   include Versions # version/reserved_domain_version.rb
   before_save :fill_empty_passwords
+  before_save :generate_data
+  before_destroy :remove_data
+  validates :name, domain_name: true, uniqueness: true
+
+
 
-  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)
-      name_in_unicode = SimpleIDN.to_ascii(domain_name)
-      by_domain(domain_name).select("names -> '#{domain_name}' AS pw").first.try(:pw) ||
-          by_domain(name_in_unicode).select("names -> '#{name_in_unicode}' AS pw").first.try(:pw)
+      name_in_ascii = SimpleIDN.to_ascii(domain_name)
+      by_domain(domain_name).first.try(:password) || by_domain(name_in_ascii).first.try(:password)
     end
 
     def by_domain name
-      where("names ? '#{name}'")
+      where(name: name)
     end
 
     def any_of_domains names
-      where("names ?| ARRAY['#{names.join("','")}']")
+      where(name: names)
     end
   end
+
+
+  def fill_empty_passwords
+
+    if self.password.empty?
+
+      self.password =  SecureRandom.hex
+
+    end
+  end
+
+  def name= val
+    super SimpleIDN.to_unicode(val)
+  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.save
+  end
+
+  def generate_body
+    template = Rails.root.join("app/views/for_models/whois_other.erb".freeze)
+    ERB.new(template.read, nil, "-").result(binding)
+  end
+
+  def generate_json
+    h = HashWithIndifferentAccess.new
+    h[:name]       = self.name
+    h[:status]     = 'Reserved'
+    h
+  end
+
+  def remove_data
+    return if Domain.where(name: name).any?
+
+    Whois::Record.where(name: name).delete_all
+  end
+
 end

app/models/soap/arireg.rb

@@ -0,0 +1,219 @@
+# coding: utf-8
+require 'savon'
+=begin
+
+Estonian Business registry provides information about registered companies via xml (SOAP over HTTPS).
+
+Note:
+  The SSL endpoint certificate is self signed.
+
+Documentation: 
+  http://www.rik.ee/et/e-ariregister/xml-teenus
+  Specifications are in Eng and Est
+  User contract required
+
+Testing:
+  https://demo-ariregxml.rik.ee:447/testariport/?wsdl
+  http://demo-ariregxml.rik.ee:81 
+  https://demo-ariregxml.rik.ee:447
+
+Live service:
+  https://ariregxml.rik.ee/ariport/?wsdl
+  https://ariregxml.rik.ee/
+
+Implements Soap::Arireg # associated_businesses
+   8. arireg.paringesindus_v4
+   Rights of representation of all persons related to the company (newer)
+   http://www2.rik.ee/schemas/xtee/arireg/live/paringesindus_v4.xsd
+   expects personal id code, to fetch list of registered  business id codes
+   returning {ident: person, ident_country_code: ... associated_businesses: [...id_codes...]}
+
+=end
+
+# do some SSL set up?
+# ssl_version
+# ssl_verify_mode
+# ssl_cert_key_file
+# ssl_cert_key
+# ssl_cert_key_password
+# ssl_cert_file
+# ssl_cert
+# ssl_ca_cert_file
+# ssl_ca_cert
+
+module Soap
+
+  class Arireg
+
+    class NotAvailableError < StandardError
+      attr_accessor :json
+      def initialize(params)
+        params[:message] = "#{I18n.t(:business_registry_service_not_available)}" unless params.key? :message
+        @json = params
+
+        super(params)
+      end
+    end
+
+    class << self
+      attr_accessor :wsdl, :host, :username, :password
+    end
+    
+    def initialize
+      if self.class.username.nil?
+        if Rails.application.secrets.key?(:arireg)
+          arireg = Rails.application.secrets[:arireg].with_indifferent_access
+          self.class.username = arireg[:username]
+          self.class.password = arireg[:password]
+          if self.class.wsdl.nil?         # no override of config/environments/* ?
+            self.class.wsdl = arireg[:wsdl]
+            self.class.host = arireg[:host]
+          end
+        else
+          self.class.username = ENV['arireg_username']
+          self.class.password = ENV['arireg_password']
+        end
+      end
+      if self.class.wsdl.nil?
+        self.class.wsdl = ENV['arireg_wsdl']
+        self.class.host = ENV['arireg_host']
+      end
+
+      # note Savon has error if https w/non-standard port,
+      # use non-standard force to pre-set endpoint
+      @client = Savon.client(wsdl: self.class.wsdl,
+                             host: self.class.host,
+                      endpoint: "#{self.class.host}/cgi-bin/consumer_proxy")
+      @session = nil
+    end
+
+    # retrieve business id codes for business that a person has a legal role
+    def associated_businesses(ident, ident_cc = 'EST')
+      begin
+        msg = {
+            'fyysilise_isiku_kood'       => ident,
+            'fyysilise_isiku_koodi_riik' => country_code_3(ident_cc)
+        }
+        Rails.logger.info "[Ariregister] Request sent with data: #{msg.inspect}"
+
+        response = @client.call :paringesindus_v4, message: body(msg)
+        content = extract response, :paringesindus_v4_response
+        Rails.logger.info "[Ariregister] Got response with data: #{content.inspect}"
+
+        if content.present? && content[:ettevotjad].key?(:item)
+          business_ident = items(content, :ettevotjad).map{|item| item[:ariregistri_kood]}
+        else
+          business_ident = []
+        end
+
+        {
+            ident: ident,
+            ident_country_code: ident_cc,
+            # ident_type: 'priv',
+            retrieved_on: Time.now,
+            associated_businesses: business_ident
+        }
+      rescue Savon::SOAPFault => fault
+        Rails.logger.error "[Ariregister] #{fault} Äriregister arireg #{self.class.username} at #{self.class.host }"
+        raise NotAvailableError.new(exception: fault)
+      rescue HTTPI::SSLError => ssl_error
+        Rails.logger.error "[Ariregister] #{ssl_error} at #{self.class.host}"
+        raise NotAvailableError.new(exception: ssl_error)
+      rescue SocketError => sock
+        Rails.logger.error "[Ariregister] #{sock}"
+        raise NotAvailableError.new(exception: sock)
+      end
+    end
+    
+    def debug
+      @client.globals.log_level :debug
+      @client.globals.log true
+      @client.globals.pretty_print_xml true
+      @debug = true
+      @client
+    end
+
+    private
+
+    # add required elements to request
+    def body(args)
+      if @session.nil? 
+        args['ariregister_kasutajanimi'] = self.class.username
+        args['ariregister_parool'] = self.class.password
+      else
+        args['ariregister_sessioon'] = @session
+      end
+      {keha: args}
+    end
+
+    # TLA --- three letter acronym required not two letter acronym, transform
+    def country_code_3(code)
+      if code.length == 2
+        code = CC2X3[code]
+        raise NotAvailableError.new(message: 'Unrecognized Country') if code.nil?
+      end
+      code
+    end
+
+    def extract(response, element)
+      # response envelope body has again header/body under element; header is user and password returned
+      response.hash[:envelope][:body][element][:keha]
+    end
+
+    def items(content, parent)
+      items = content[parent][:item]
+      items.is_a?(Array) ? items : [items]
+    end
+
+    CC2X3 = {"AF"=>"AFG", "AX"=>"ALA", "AL"=>"ALB", "DZ"=>"DZA", "AS"=>"ASM",
+             "AD"=>"AND", "AO"=>"AGO", "AI"=>"AIA", "AQ"=>"ATA", "AG"=>"ATG",
+             "AR"=>"ARG", "AM"=>"ARM", "AW"=>"ABW", "AU"=>"AUS", "AT"=>"AUT",
+             "AZ"=>"AZE", "BS"=>"BHS", "BH"=>"BHR", "BD"=>"BGD", "BB"=>"BRB",
+             "BY"=>"BLR", "BE"=>"BEL", "BZ"=>"BLZ", "BJ"=>"BEN", "BM"=>"BMU",
+             "BT"=>"BTN", "BO"=>"BOL", "BQ"=>"BES", "BA"=>"BIH", "BW"=>"BWA",
+             "BV"=>"BVT", "BR"=>"BRA", "IO"=>"IOT", "BN"=>"BRN", "BG"=>"BGR",
+             "BF"=>"BFA", "BI"=>"BDI", "CV"=>"CPV", "KH"=>"KHM", "CM"=>"CMR",
+             "CA"=>"CAN", "KY"=>"CYM", "CF"=>"CAF", "TD"=>"TCD", "CL"=>"CHL",
+             "CN"=>"CHN", "CX"=>"CXR", "CC"=>"CCK", "CO"=>"COL", "KM"=>"COM",
+             "CD"=>"COD", "CG"=>"COG", "CK"=>"COK", "CR"=>"CRI", "CI"=>"CIV",
+             "HR"=>"HRV", "CU"=>"CUB", "CW"=>"CUW", "CY"=>"CYP", "CZ"=>"CZE",
+             "DK"=>"DNK", "DJ"=>"DJI", "DM"=>"DMA", "DO"=>"DOM", "EC"=>"ECU",
+             "EG"=>"EGY", "SV"=>"SLV", "GQ"=>"GNQ", "ER"=>"ERI", "EE"=>"EST",
+             "ET"=>"ETH", "FK"=>"FLK", "FO"=>"FRO", "FJ"=>"FJI", "FI"=>"FIN",
+             "FR"=>"FRA", "GF"=>"GUF", "PF"=>"PYF", "TF"=>"ATF", "GA"=>"GAB",
+             "GM"=>"GMB", "GE"=>"GEO", "DE"=>"DEU", "GH"=>"GHA", "GI"=>"GIB",
+             "GR"=>"GRC", "GL"=>"GRL", "GD"=>"GRD", "GP"=>"GLP", "GU"=>"GUM",
+             "GT"=>"GTM", "GG"=>"GGY", "GN"=>"GIN", "GW"=>"GNB", "GY"=>"GUY",
+             "HT"=>"HTI", "HM"=>"HMD", "VA"=>"VAT", "HN"=>"HND", "HK"=>"HKG",
+             "HU"=>"HUN", "IS"=>"ISL", "IN"=>"IND", "ID"=>"IDN", "IR"=>"IRN",
+             "IQ"=>"IRQ", "IE"=>"IRL", "IM"=>"IMN", "IL"=>"ISR", "IT"=>"ITA",
+             "JM"=>"JAM", "JP"=>"JPN", "JE"=>"JEY", "JO"=>"JOR", "KZ"=>"KAZ",
+             "KE"=>"KEN", "KI"=>"KIR", "KP"=>"PRK", "KR"=>"KOR", "KW"=>"KWT",
+             "KG"=>"KGZ", "LA"=>"LAO", "LV"=>"LVA", "LB"=>"LBN", "LS"=>"LSO",
+             "LR"=>"LBR", "LY"=>"LBY", "LI"=>"LIE", "LT"=>"LTU", "LU"=>"LUX",
+             "MO"=>"MAC", "MK"=>"MKD", "MG"=>"MDG", "MW"=>"MWI", "MY"=>"MYS",
+             "MV"=>"MDV", "ML"=>"MLI", "MT"=>"MLT", "MH"=>"MHL", "MQ"=>"MTQ",
+             "MR"=>"MRT", "MU"=>"MUS", "YT"=>"MYT", "MX"=>"MEX", "FM"=>"FSM",
+             "MD"=>"MDA", "MC"=>"MCO", "MN"=>"MNG", "ME"=>"MNE", "MS"=>"MSR",
+             "MA"=>"MAR", "MZ"=>"MOZ", "MM"=>"MMR", "NA"=>"NAM", "NR"=>"NRU",
+             "NP"=>"NPL", "NL"=>"NLD", "NC"=>"NCL", "NZ"=>"NZL", "NI"=>"NIC",
+             "NE"=>"NER", "NG"=>"NGA", "NU"=>"NIU", "NF"=>"NFK", "MP"=>"MNP",
+             "NO"=>"NOR", "OM"=>"OMN", "PK"=>"PAK", "PW"=>"PLW", "PS"=>"PSE",
+             "PA"=>"PAN", "PG"=>"PNG", "PY"=>"PRY", "PE"=>"PER", "PH"=>"PHL",
+             "PN"=>"PCN", "PL"=>"POL", "PT"=>"PRT", "PR"=>"PRI", "QA"=>"QAT",
+             "RE"=>"REU", "RO"=>"ROU", "RU"=>"RUS", "RW"=>"RWA", "BL"=>"BLM",
+             "SH"=>"SHN", "KN"=>"KNA", "LC"=>"LCA", "MF"=>"MAF", "PM"=>"SPM",
+             "VC"=>"VCT", "WS"=>"WSM", "SM"=>"SMR", "ST"=>"STP", "SA"=>"SAU",
+             "SN"=>"SEN", "RS"=>"SRB", "SC"=>"SYC", "SL"=>"SLE", "SG"=>"SGP",
+             "SX"=>"SXM", "SK"=>"SVK", "SI"=>"SVN", "SB"=>"SLB", "SO"=>"SOM",
+             "ZA"=>"ZAF", "GS"=>"SGS", "SS"=>"SSD", "ES"=>"ESP", "LK"=>"LKA",
+             "SD"=>"SDN", "SR"=>"SUR", "SJ"=>"SJM", "SZ"=>"SWZ", "SE"=>"SWE",
+             "CH"=>"CHE", "SY"=>"SYR", "TW"=>"TWN", "TJ"=>"TJK", "TZ"=>"TZA",
+             "TH"=>"THA", "TL"=>"TLS", "TG"=>"TGO", "TK"=>"TKL", "TO"=>"TON",
+             "TT"=>"TTO", "TN"=>"TUN", "TR"=>"TUR", "TM"=>"TKM", "TC"=>"TCA",
+             "TV"=>"TUV", "UG"=>"UGA", "UA"=>"UKR", "AE"=>"ARE", "GB"=>"GBR",
+             "UM"=>"UMI", "US"=>"USA", "UY"=>"URY", "UZ"=>"UZB", "VU"=>"VUT",
+             "VE"=>"VEN", "VN"=>"VNM", "VG"=>"VGB", "VI"=>"VIR", "WF"=>"WLF",
+             "EH"=>"ESH", "YE"=>"YEM", "ZM"=>"ZMB", "ZW"=>"ZWE"}
+  end
+end

app/models/whois_record.rb

@@ -23,6 +23,10 @@ class WhoisRecord < ActiveRecord::Base
     end
   end
 
+  def self.find_by_name(name)
+    WhoisRecord.where("lower(name) = ?", name.downcase)
+  end
+
   def generated_json
     @generated_json ||= generate_json
   end
@@ -44,11 +48,11 @@ class WhoisRecord < ActiveRecord::Base
     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)
+    h[:delete]     = [domain.delete_at, domain.force_delete_at].compact.min.try(:to_date).try(:to_s)
 
 
     h[:registrant]       = domain.registrant.name
-    h[:registrant_email] = domain.registrant.email
+    h[:email] = domain.registrant.email
     @disclosed << [:email, domain.registrant.email]
     h[:registrant_changed]          = domain.registrant.updated_at.try(:to_s, :iso8601)
 
@@ -102,7 +106,7 @@ class WhoisRecord < ActiveRecord::Base
     self.json = generated_json
     self.body = generated_body
     self.name = json['name']
-    self.registrar_id = domain.registrar_id # for faster registrar updates
+    self.registrar_id = domain.registrar_id if domain # for faster registrar updates
   end
 
   def update_whois_server
@@ -113,6 +117,6 @@ class WhoisRecord < ActiveRecord::Base
   end
 
   def destroy_whois_record
-    Whois::Record.where(name: name).delete_all()
+    Whois::Record.where(name: name).delete_all
   end
 end