diff --git a/app/models/legacy/dnskey_history.rb b/app/models/legacy/dnskey_history.rb index 1f62b1002..32a9cd855 100644 --- a/app/models/legacy/dnskey_history.rb +++ b/app/models/legacy/dnskey_history.rb @@ -4,5 +4,50 @@ module Legacy belongs_to :object_registry, foreign_key: :id belongs_to :object, foreign_key: :id + has_one :object_history, foreign_key: :historyid, primary_key: :historyid + + + def self.for_at(keysetid, time) + return [] unless keysetid + + sql = %Q{select distinct dh.id, dh.keysetid, dh.flags, dh.protocol, dh.alg, dh.key, + first_value(history.valid_from) OVER (PARTITION BY key ORDER BY history.valid_from ASC NULLS FIRST) valid_from, + first_value(history.valid_to) OVER (PARTITION BY key ORDER BY history.valid_to DESC NULLS FIRST) valid_to + FROM dnskey_history dh JOIN history ON dh.historyid=history.id + WHERE dh.keysetid IN (#{keysetid}) + AND (valid_from is null or valid_from <= '#{time.to_s}'::TIMESTAMPTZ) + AND (valid_to is null or valid_to >= '#{time}'::TIMESTAMPTZ) + ORDER BY dh.id;} + find_by_sql(sql) + end + + def new_object_hash(old_domain, new_domain) + new_object_mains(new_domain).merge( + creator_str: old_domain.object_registry.try(:registrar).try(:name), + updator_str: old_domain.object_history.try(:registrar).try(:name) || old_domain.object_registry.try(:registrar).try(:name), + legacy_domain_id: old_domain.id, + legacy_keyset_id: keysetid, + updated_at: (!object_registry.try(:object_history) || object_registry.try(:object_history).read_attribute(:update).nil?) ? (try(:crdate)||Time.zone.now) : object_registry.try(:object_history).read_attribute(:update) + ) + end + + def new_object_mains(new_domain) + @new_object_mains ||= { + domain_id: new_domain.id, + flags: flags, + protocol: protocol, + alg: alg, + public_key: key + } + end + + def historical_data(old_domain, new_domain, time_attr = :valid_from) + { + whodunnit: old_domain.history_domain.user.try(:id), + object: nil, + object_changes: new_object_hash(old_domain, new_domain).each_with_object({}){|(k,v), h| h[k] = [nil, v]}, + created_at: [try(time_attr), old_domain.try(time_attr)].max + } + end end end diff --git a/app/models/legacy/domain_history.rb b/app/models/legacy/domain_history.rb index 5ea18947a..44dacad90 100644 --- a/app/models/legacy/domain_history.rb +++ b/app/models/legacy/domain_history.rb @@ -2,6 +2,7 @@ module Legacy class DomainHistory < Db self.table_name = :domain_history self.primary_key = :id + class_attribute :dnssecs belongs_to :object_registry, foreign_key: :id belongs_to :object, foreign_key: :id @@ -123,6 +124,44 @@ module Legacy end end + # returns imported dnskey ids + def import_dnskeys_history(new_domain, time) + self.class.dnssecs ||= {} + self.class.dnssecs[id] ||= {} + ids = [] + Legacy::DnskeyHistory.for_at(keyset, time).each do |dns| + # checking if we have create history for dnskey (cache) + if val = self.class.dnssecs[id][dns] + ids << val + else # if not found we should check current dnssec and historical if changes were done + # if current object wan't changed + if item=::Dnskey.where(dns.new_object_mains(new_domain)).first + item.versions.where(event: :create).first_or_create!(dns.historical_data(self, new_domain)) + self.class.dnssecs[id][dns] = item.id + ids << item.id + # if current object was changed + elsif (versions = ::DnskeyVersion.where("object->>'legacy_domain_id'='#{id}'").to_a).any? + versions.each do |v| + if v.object.slice(*dns.new_object_mains(new_domain).stringify_keys.keys) == dns.new_object_mains(new_domain).keys + self.class.dnssecs[id][dns] = v.item_id + ids << v.item_id + v.item.versions.where(event: :create).first_or_create!(dns.historical_data(self, new_domain)) + end + end + else + item=::Dnskey.new(id: ::Dnskey.next_id) + DnskeyVersion.where(item_type: ::Dnskey.to_s, item_id: item.id).where(event: :create).first_or_create!(dns.historical_data(self, new_domain)) + DnskeyVersion.where(item_type: ::Dnskey.to_s, item_id: item.id).where(event: :destroy).first_or_create!(dns.historical_data(self, new_domain), :valid_to) if dns.valid_to + self.class.dnssecs[id][dns] = item.id + ids << item.id + end + end + end + + ids + end + + class << self def changes_dates_for domain_id sql = %Q{SELECT dh.*, valid_from diff --git a/lib/tasks/import_history.rake b/lib/tasks/import_history.rake index b982492cb..c9fad7768 100644 --- a/lib/tasks/import_history.rake +++ b/lib/tasks/import_history.rake @@ -2,7 +2,6 @@ namespace :import do desc 'Import all history' task history_all: :environment do Rake::Task['import:history_contacts'].invoke - Rake::Task['import:history_dnskeys'].invoke Rake::Task['import:history_domains'].invoke end @@ -78,63 +77,6 @@ namespace :import do end - desc 'Import contact history' - task history_dnskeys: :environment do - Legacy::DnskeyHistory.uniq.pluck(:id).each do |legacy_dnskey_id| - Dnskey.transaction do - contact = Dnskey.find_by(legacy_id: legacy_dnskey_id) - version_dns = DnskeytVersion.where("object->>'legacy_id' = '#{legacy_dnskey_id}'").select(:item_id).first - contact ||= Dnskey.new(id: version_dns.item_id, legacy_id: legacy_dnskey_id) if version_dns - contact ||= Dnskey.new(id: ::Contact.next_id, legacy_id: legacy_dnskey_id) - next if contact.versions.where(event: :create).any? - # add here to skip domains whith create history - - last_changes = nil - history = Legacy::ContactHistory.changes_dates_for(legacy_dnskey_id) - last_contact_action = history.sort.last[1].last # need to identify if we delete - - keys = history.keys.compact.sort - i = 0 - keys.each_with_index do |time| - history[time].each do |orig_history_klass| - changes = {} - responder = orig_history_klass[:klass].get_record_at(legacy_dnskey_id, orig_history_klass[:id]) - new_attrs = responder.get_current_contact_object(time, orig_history_klass[:param]) - new_attrs[:id] = contact.id - - event = :update - event = :create if i == 0 - if orig_history_klass == last_contact_action && responder.valid_to.present? - event = :destroy - new_attrs = {} - end - - new_attrs.each do |k, v| - if (old_val = last_changes.to_h[k]) != v then changes[k] = [old_val, v] end - end - next if changes.blank? && event != :destroy - obj_his = Legacy::ObjectHistory.find_by(historyid: responder.historyid) - user = Registrar.find_by(legacy_id: obj_his.upid || obj_his.clid).try(:api_users).try(:first) - - hash = { - item_type: Dnskey.to_s, - item_id: contact.id, - event: event, - whodunnit: user.try(:id), - object: last_changes, - object_changes: changes, - created_at: time - } - DnskeyVersion.create!(hash) - - last_changes = new_attrs - i += 1 - end - end - end - end - end - desc 'Import domain history' task history_domains: :environment do @@ -200,7 +142,7 @@ namespace :import do admin_contacts: responder.history_domain.get_admin_contact_new_ids, tech_contacts: responder.history_domain.get_tech_contact_new_ids, nameservers: [], - dnskeys: [], + dnskeys: responder.history_domain.import_dnskeys_history(domain, time), registrant: [responder.history_domain.new_registrant_id] } )