Merge pull request #1774 from internetee/repp-domains

REPP: Domain management

lib/core_monkey_patches/hash.rb

@@ -0,0 +1,5 @@
+class Hash
+  def select_keys(*args)
+    select { |k, _| args.include?(k) }.map { |_k, v| v }
+  end
+end

lib/deserializers/xml/dnssec.rb

@@ -0,0 +1,95 @@
+module Deserializers
+  module Xml
+    class DnssecKey
+      attr_reader :frame, :dsa
+
+      KEY_INTERFACE = { flags: 'flags', protocol: 'protocol', alg: 'alg',
+                        public_key: 'pubKey' }.freeze
+      DS_INTERFACE  = { ds_key_tag: 'keyTag', ds_alg: 'alg', ds_digest_type: 'digestType',
+                        ds_digest: 'digest' }.freeze
+
+      def initialize(frame, dsa)
+        @frame = frame
+        @dsa = dsa
+      end
+
+      def call
+        dsa ? ds_alg_output : xm_copy(frame, KEY_INTERFACE)
+      end
+
+      def ds_alg_output
+        ds_key = xm_copy(frame, DS_INTERFACE)
+        ds_key.merge(xm_copy(frame.css('keyData'), KEY_INTERFACE)) if frame.css('keyData').present?
+        ds_key
+      end
+
+      def other_alg_output
+        xm_copy(frame, KEY_INTERFACE)
+      end
+
+      private
+
+      def xm_copy(entry, map)
+        result = {}
+        map.each do |key, elem|
+          result[key] = entry.css(elem).first.try(:text)
+        end
+        result
+      end
+    end
+
+    class DnssecKeys
+      attr_reader :frame, :key_data, :ds_data
+
+      def initialize(frame)
+        @key_data = []
+        @ds_data = []
+
+        # schema validation prevents both in the same parent node
+        if frame.css('dsData').present?
+          frame.css('dsData').each { |k| @ds_data << key_from_params(k, dsa: true) }
+        end
+
+        return if frame.css('keyData').blank?
+
+        frame.css('keyData').each { |k| @key_data << key_from_params(k, dsa: false) }
+      end
+
+      def key_from_params(obj, dsa: false)
+        Deserializers::Xml::DnssecKey.new(obj, dsa).call
+      end
+
+      def call
+        key_data + ds_data
+      end
+
+      def mark_destroy_all(dns_keys)
+        # if transition support required mark_destroy dns_keys when has ds/key values otherwise ...
+        dns_keys.map { |inf_data| mark(inf_data) }
+      end
+
+      def mark_destroy(dns_keys)
+        data = ds_data.present? ? ds_filter(dns_keys) : kd_filter(dns_keys)
+        data.each { |inf_data| inf_data.blank? ? nil : mark(inf_data) }
+      end
+
+      private
+
+      def ds_filter(dns_keys)
+        @ds_data.map do |ds|
+          dns_keys.find_by(ds.slice(*DS_INTERFACE.keys))
+        end
+      end
+
+      def kd_filter(dns_keys)
+        @key_data.map do |key|
+          dns_keys.find_by(key)
+        end
+      end
+
+      def mark(inf_data)
+        { id: inf_data.id, _destroy: 1 }
+      end
+    end
+  end
+end

lib/deserializers/xml/domain.rb

@@ -0,0 +1,61 @@
+module Deserializers
+  module Xml
+    class Domain
+      attr_reader :frame, :registrar
+
+      def initialize(frame, registrar)
+        @frame = frame
+        @registrar = registrar
+      end
+
+      def call
+        attributes = {
+          name: if_present('name'),
+          registrar: registrar,
+          registrant: if_present('registrant'),
+          reserved_pw: if_present('reserved > pw'),
+        }
+
+        attributes.merge!(assign_period_attributes)
+
+        pw = frame.css('authInfo > pw').text
+        attributes[:transfer_code] = pw if pw.present?
+        attributes.compact
+      end
+
+      def assign_period_attributes
+        period = frame.css('period')
+
+        {
+          period: period.text.present? ? Integer(period.text) : 1,
+          period_unit: period.first ? period.first[:unit] : 'y',
+          exp_date: if_present('curExpDate'),
+        }
+      end
+
+      def if_present(css_path)
+        return if frame.css(css_path).blank?
+
+        frame.css(css_path).text
+      end
+
+      def statuses_to_add
+        statuses_frame = frame.css('add')
+        return if statuses_frame.blank?
+
+        statuses_frame.css('status').map do |status|
+          status['s']
+        end
+      end
+
+      def statuses_to_remove
+        statuses_frame = frame.css('rem')
+        return if statuses_frame.blank?
+
+        statuses_frame.css('status').map do |status|
+          status['s']
+        end
+      end
+    end
+  end
+end

lib/deserializers/xml/domain_create.rb

@@ -0,0 +1,52 @@
+require 'deserializers/xml/legal_document'
+require 'deserializers/xml/domain'
+require 'deserializers/xml/nameserver'
+require 'deserializers/xml/dnssec'
+module Deserializers
+  module Xml
+    class DomainCreate
+      attr_reader :frame
+      attr_reader :registrar
+
+      def initialize(frame, registrar)
+        @frame = frame
+        @registrar = registrar
+      end
+
+      def call
+        obj = domain
+        obj[:admin_contacts] = admin_contacts
+        obj[:tech_contacts] = tech_contacts
+        obj[:nameservers_attributes] = nameservers
+        obj[:dnskeys_attributes] = dns_keys
+        obj[:legal_document] = legal_document
+
+        obj
+      end
+
+      def domain
+        @domain ||= ::Deserializers::Xml::Domain.new(frame, registrar).call
+      end
+
+      def nameservers
+        @nameservers ||= ::Deserializers::Xml::Nameservers.new(frame).call
+      end
+
+      def admin_contacts
+        frame.css('contact').select { |c| c['type'] == 'admin' }.map(&:text)
+      end
+
+      def tech_contacts
+        frame.css('contact').select { |c| c['type'] == 'tech' }.map(&:text)
+      end
+
+      def dns_keys
+        @dns_keys ||= ::Deserializers::Xml::DnssecKeys.new(frame).key_data
+      end
+
+      def legal_document
+        @legal_document ||= ::Deserializers::Xml::LegalDocument.new(frame).call
+      end
+    end
+  end
+end

lib/deserializers/xml/domain_delete.rb

@@ -0,0 +1,20 @@
+module Deserializers
+  module Xml
+    class DomainDelete
+      attr_reader :frame
+
+      def initialize(frame)
+        @frame = frame
+      end
+
+      def call
+        obj = {}
+        obj[:name] = frame.css('name')&.text
+        verify = frame.css('delete').children.css('delete').attr('verified').to_s.downcase == 'yes'
+        obj[:delete] = { verified: verify }
+
+        obj
+      end
+    end
+  end
+end

lib/deserializers/xml/domain_update.rb

@@ -0,0 +1,89 @@
+require 'deserializers/xml/legal_document'
+require 'deserializers/xml/domain'
+require 'deserializers/xml/nameserver'
+require 'deserializers/xml/dnssec'
+module Deserializers
+  module Xml
+    class DomainUpdate
+      attr_reader :frame, :registrar
+
+      def initialize(frame, registrar)
+        @frame = frame
+        @registrar = registrar
+        @legal_document ||= ::Deserializers::Xml::LegalDocument.new(frame).call
+      end
+
+      def call
+        obj = { domain: frame.css('name')&.text, registrant: registrant, contacts: contacts,
+                transfer_code: if_present('authInfo > pw'), nameservers: nameservers,
+                registrar_id: registrar, statuses: statuses, dns_keys: dns_keys,
+                reserved_pw: if_present('reserved > pw'), legal_document: @legal_document }
+
+        obj.reject { |_key, val| val.blank? }
+      end
+
+      def registrant
+        return if frame.css('chg > registrant').blank?
+
+        { code: frame.css('chg > registrant').text,
+          verified: frame.css('chg > registrant').attr('verified').to_s.downcase == 'yes' }
+      end
+
+      def contacts
+        contacts = []
+        frame.css('add > contact').each do |c|
+          contacts << { code: c.text, type: c['type'], action: 'add' }
+        end
+
+        frame.css('rem > contact').each do |c|
+          contacts << { code: c.text, type: c['type'], action: 'rem' }
+        end
+
+        contacts.presence
+      end
+
+      def nameservers
+        @nameservers = []
+
+        frame.css('add > ns > hostAttr').each { |ns| assign_ns(ns) }
+        frame.css('rem > ns > hostAttr').each { |ns| assign_ns(ns, add: false) }
+
+        @nameservers.presence
+      end
+
+      def assign_ns(nameserver, add: true)
+        nsrv = Deserializers::Xml::Nameserver.new(nameserver).call
+        nsrv[:action] = add ? 'add' : 'rem'
+        @nameservers << nsrv
+      end
+
+      def dns_keys
+        added = ::Deserializers::Xml::DnssecKeys.new(frame.css('add')).call
+        added.each { |k| k[:action] = 'add' }
+        removed = ::Deserializers::Xml::DnssecKeys.new(frame.css('rem')).call
+        removed.each { |k| k[:action] = 'rem' }
+
+        return if (added + removed).blank?
+
+        added + removed
+      end
+
+      def statuses
+        return if frame.css('status').blank?
+
+        s = []
+
+        frame.css('add > status').each { |e| s << { status: e.attr('s'), action: 'add' } }
+        frame.css('rem > status').each { |e| s << { status: e.attr('s'), action: 'rem' } }
+
+        s
+      end
+
+      def if_present(css_path)
+        return if frame.css(css_path).blank?
+
+        frame.css(css_path).text
+      end
+    end
+  end
+end

lib/deserializers/xml/nameserver.rb

@@ -0,0 +1,37 @@
+module Deserializers
+  module Xml
+    class Nameserver
+      attr_reader :frame
+
+      def initialize(frame)
+        @frame = frame
+      end
+
+      def call
+        {
+          hostname: frame.css('hostName').text,
+          ipv4: frame.css('hostAddr[ip="v4"]').map(&:text).compact,
+          ipv6: frame.css('hostAddr[ip="v6"]').map(&:text).compact,
+        }
+      end
+    end
+
+    class Nameservers
+      attr_reader :frame
+
+      def initialize(frame)
+        @frame = frame
+      end
+
+      def call
+        res = []
+        frame.css('hostAttr').each do |ns|
+          ns = Deserializers::Xml::Nameserver.new(ns).call
+          res << ns.delete_if { |_k, v| v.blank? }
+        end
+
+        res
+      end
+    end
+  end
+end

lib/serializers/repp/contact.rb

@@ -10,7 +10,7 @@ module Serializers
 
       def to_json(obj = contact)
         json = { id: obj.code, name: obj.name, ident: ident,
-                 email: obj.email, phone: obj.phone, fax: obj.fax,
+                 email: obj.email, phone: obj.phone,
                  auth_info: obj.auth_info, statuses: obj.statuses,
                  disclosed_attributes: obj.disclosed_attributes }
 

lib/serializers/repp/domain.rb

@@ -0,0 +1,45 @@
+module Serializers
+  module Repp
+    class Domain
+      attr_reader :domain
+
+      def initialize(domain, sponsored: true)
+        @domain = domain
+        @sponsored = sponsored
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def to_json(obj = domain)
+        json = {
+          name: obj.name, registrant: obj.registrant.code, created_at: obj.created_at,
+          updated_at: obj.updated_at, expire_time: obj.expire_time, outzone_at: obj.outzone_at,
+          delete_date: obj.delete_date, force_delete_date: obj.force_delete_date,
+          contacts: contacts, nameservers: nameservers, dnssec_keys: dnssec_keys,
+          statuses: obj.statuses, registrar: registrar
+        }
+        json[:transfer_code] = obj.auth_info if @sponsored
+        json
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def contacts
+        domain.domain_contacts.map { |c| { code: c.contact_code_cache, type: c.type } }
+      end
+
+      def nameservers
+        domain.nameservers.map { |ns| { hostname: ns.hostname, ipv4: ns.ipv4, ipv6: ns.ipv6 } }
+      end
+
+      def dnssec_keys
+        domain.dnskeys.map do |nssec|
+          { flags: nssec.flags, protocol: nssec.protocol, alg: nssec.alg,
+            public_key: nssec.public_key }
+        end
+      end
+
+      def registrar
+        { name: domain.registrar.name, website: domain.registrar.website }
+      end
+    end
+  end
+end