epp-ruby 3.0.0

data/lib/epp-client/contact/update.rb

@@ -0,0 +1,80 @@
+require File.expand_path('../command', __FILE__)
+
+module EPP
+  module Contact
+    class Update < Command
+      ADD_REM_ORDER = [:status]
+      CHG_ORDER     = [:postal_info, :voice, :fax, :email, :auth_info, :disclose]
+
+      # @option [Hash] :status A Hash of status value to text. Text may optionally be an array in the form ["Text", "lang"] if a custom language value needs to be set.
+      def initialize(id, options = {})
+        @id  = id
+        @add = options.delete(:add) || {}
+        @rem = options.delete(:rem) || {}
+        @chg = options.delete(:chg) || {}
+
+        @add.delete_if { |k,_| !ADD_REM_ORDER.include?(k) }
+        @rem.delete_if { |k,_| !ADD_REM_ORDER.include?(k) }
+        @chg.delete_if { |k,_| !CHG_ORDER.include?(k) }
+      end
+
+      def name
+        'update'
+      end
+
+      def to_xml
+        node = super
+        node << contact_node('id', @id)
+
+        unless @add.empty?
+          node << add = contact_node('add')
+          add_rem_to_xml(add, @add)
+        end
+
+        unless @rem.empty?
+          node << rem = contact_node('rem')
+          add_rem_to_xml(rem, @rem)
+        end
+
+        unless @chg.empty?
+          node << chg = contact_node('chg')
+          CHG_ORDER.each do |key|
+            value = @chg[key]
+            next if value.nil? || value.empty?
+            
+            case key
+            when :postal_info
+              chg << postal_info_to_xml(value)
+            when :auth_info
+              chg << auth_info_to_xml(value)
+            when :disclose
+              chg << disclose_to_xml(value)
+            when :voice, :fax, :email
+              chg << contact_node(key.to_s, value)
+            end
+          end
+        end
+        
+        node
+      end
+
+      protected
+        def add_rem_to_xml(node, hash)
+          ADD_REM_ORDER.each do |key|
+            value = hash[key]
+            next if value.nil? || value.empty?
+
+            case key
+            when :status
+              value.each do |status, text|
+                text, lang = Array(text)
+                node << s = contact_node('status', text)
+                s['lang'] = lang if lang
+                s['s'] = status.to_s
+              end
+            end
+          end
+        end
+    end
+  end
+end

data/lib/epp-client/contact/update_response.rb

@@ -0,0 +1,9 @@
+require File.expand_path('../response', __FILE__)
+
+module EPP
+  module Contact
+    class UpdateResponse < Response
+      
+    end
+  end
+end

data/lib/epp-client/domain/check.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../command', __FILE__)
+
+module EPP
+  module Domain
+    class Check < Command
+      def initialize(*names)
+        @names = names.flatten
+      end
+
+      def name
+        'check'
+      end
+
+      def to_xml
+        node = super
+        @names.each do |name|
+          node << domain_node('name', name)
+        end
+        node
+      end
+    end
+  end
+end

data/lib/epp-client/domain/check_response.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../response', __FILE__)
+
+module EPP
+  module Domain
+    class CheckResponse < Response
+      def available?(name = nil)
+        return availability[name] if name
+
+        if name.nil? && availability.count == 1
+          return availability.values.first
+        end
+
+        raise ArgumentError, "name must be specified if more than one domain checked"
+      end
+      def unavailable?(name = nil)
+        !available?(name)
+      end
+
+      def names
+        availability.keys
+      end
+
+      def name
+        raise "name unavailable when more than one domain checked, use #names" if count != 1
+        names.first
+      end
+
+      def count
+        availability.count
+      end
+
+      protected
+        def availability
+          @availability ||= nodes_for_xpath('//domain:name').inject({}) do |hash, node|
+            hash[node.content.strip] = node['avail'] == '1'
+            hash
+          end
+        end
+    end
+  end
+end

data/lib/epp-client/domain/command.rb

@@ -0,0 +1,92 @@
+module EPP
+  module Domain
+    class Command
+      include XMLHelpers
+      attr_reader :namespaces
+
+      def set_namespaces(namespaces)
+        @namespaces = namespaces
+      end
+
+      def name
+        raise NotImplementedError, "#name must be implemented in subclasses"
+      end
+
+      def to_xml
+        @namespaces ||= {}
+        node = domain_node(name)
+
+        xattr = XML::Attr.new(node, "schemaLocation", SCHEMA_LOCATION)
+        xattr.namespaces.namespace = @namespaces['xsi'] || XML::Namespace.new(node, 'xsi', 'http://www.w3.org/2001/XMLSchema-instance')
+        
+        node
+      end
+
+      protected
+        def domain_node(name, value = nil)
+          node = xml_node(name, value)
+          node.namespaces.namespace = domain_namespace(node)
+          node
+        end
+        def domain_namespace(node)
+          return @namespaces['domain'] if @namespaces.has_key?('domain')
+          @namespaces['domain'] = xml_namespace(node, 'domain', NAMESPACE)
+        end
+        
+        def validate_period(period)
+          unit = period[-1,1].downcase
+          val  = period.to_i
+          
+          raise ArgumentError, "period suffix must either be 'm' or 'y'" unless %w(m y).include?(unit)
+          raise ArgumentError, "period value must be in the range 1-99" if val < 1 || val > 99
+          
+          return val.to_s, unit
+        end
+
+        def auth_info_to_xml(auth_info)
+          a = domain_node('authInfo')
+
+          if auth_info.has_key?(:pw)
+            a << pw = domain_node('pw', auth_info[:pw])
+            pw['roid'] = auth_info[:roid] if auth_info.has_key?(:roid)
+          elsif auth_info.has_key?(:ext)
+            a << domain_node('ext', auth_info[:ext])
+          end
+
+          a
+        end
+        
+        def nameservers_to_xml(nameservers)
+          ns = domain_node('ns')
+
+          nameservers.each do |nameserver|
+            case nameserver
+            when String
+              ns << domain_node('hostObj', nameserver)
+            when Hash
+              ns << hostAttr = domain_node('hostAttr')
+              hostAttr << domain_node('hostName', nameserver[:name])
+              Array(nameserver[:ipv4]).each do |addr|
+                hostAttr << a = domain_node('hostAddr', addr)
+                a['ip'] = 'v4'
+              end
+              Array(nameserver[:ipv6]).each do |addr|
+                hostAttr << a = domain_node('hostAddr', addr)
+                a['ip'] = 'v6'
+              end
+            end
+          end
+
+          ns
+        end
+        def contacts_to_xml(node, contacts)
+          return if contacts.nil?
+          contacts.each do |type, roid|
+            next unless %w(admin tech billing).include?(type.to_s)
+            node << c = domain_node('contact', roid)
+            c['type'] = type.to_s
+          end
+        end
+    end
+  end
+end

data/lib/epp-client/domain/create.rb

@@ -0,0 +1,75 @@
+require File.expand_path('../command', __FILE__)
+
+module EPP
+  module Domain
+    class Create < Command
+      # Domain creation command.
+      #
+      # @param [String] name Name of domain to create
+      # @param [Hash] options Options to use to create the domain
+      # @option options [String] period Years or months period to create the domain for
+      # @option options [Array<String,Hash>] Array or hash of nameservers
+      # @option options [String] registrant Contact handle to use as registrant
+      # @option options [Hash<Symbol,String>] contacts Hash of admin, tech, billing contacts
+      # @option options [Hash<Symbol,String>] auth_info Hash of auth info
+      # @return [EPP::Domain::Create]
+      #
+      # @example Create a domain
+      #   command = EPP::Domain::Create.new('example.com',
+      #     period: '1y', registrant: 'test9023742684',
+      #     auth_info: { pw: 'domainpassword' },
+      #     contacts: { admin: 'admin123', tech: 'admin123', billing: 'admin123' },
+      #     nameservers: ['ns1.test.host', 'ns2.test.host']
+      #   )
+      #
+      # @example Create a domain with nameserver glue
+      #   command = EPP::Domain::Create.new('example.com',
+      #     period: '1y', registrant: 'test9023742684',
+      #     auth_info: { pw: 'domainpassword' },
+      #     contacts: { admin: 'admin123', tech: 'admin123', billing: 'admin123' },
+      #     nameservers: [
+      #       {name: 'ns1.example.com', ipv4: '198.51.100.53'}
+      #       {name: 'ns2.example.com', ipv4: '198.51.100.54'}
+      #     ]
+      #   )
+      def initialize(name, options = {})
+        @name = name
+        @period = options.delete(:period) || '1y'
+        @nameservers = Array(options.delete(:nameservers))
+        @registrant = options.delete(:registrant)
+        @contacts = options.delete(:contacts)
+        @auth_info = options.delete(:auth_info)
+
+        @period_val, @period_unit = validate_period(@period)
+      end
+
+      def name
+        'create'
+      end
+
+      def to_xml
+        node = super
+        node << domain_node('name', @name)
+
+        if @period_val && @period_unit
+          p = domain_node('period', @period_val)
+          p['unit'] = @period_unit
+
+          node << p
+        end
+
+        unless @nameservers.empty?
+          node << nameservers_to_xml(@nameservers)
+        end
+
+        node << domain_node('registrant', @registrant) if @registrant
+
+        contacts_to_xml(node, @contacts)
+
+        node << auth_info_to_xml(@auth_info) unless @auth_info.empty?
+
+        node
+      end
+    end
+  end
+end

data/lib/epp-client/domain/create_response.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../response', __FILE__)
+
+module EPP
+  module Domain
+    class CreateResponse < Response
+      # Return the name of the domain created if successful
+      #
+      # @return [String] Name of created domain
+      def name
+        return nil unless success?
+        @name ||= value_for_xpath('//domain:name')
+      end
+      # Return the creation/registration date of the domain if the request was successful.
+      #
+      # @return [Time] Registration time
+      def creation_date
+        return nil unless success?
+        @crdate ||= value_for_xpath('//domain:crDate') && Time.parse(value_for_xpath('//domain:crDate'))
+      end
+      # Return the expiration date of the domain if the request was successful.
+      #
+      # @return [Time] Expiration time
+      def expiration_date
+        return nil unless success?
+        @exdate ||= value_for_xpath('//domain:exDate') && Time.parse(value_for_xpath('//domain:exDate'))
+      end
+    end
+  end
+end

data/lib/epp-client/domain/delete.rb

@@ -0,0 +1,21 @@
+require File.expand_path('../command', __FILE__)
+
+module EPP
+  module Domain
+    class Delete < Command
+      def initialize(name)
+        @name = name
+      end
+
+      def name
+        'delete'
+      end
+
+      def to_xml
+        node = super
+        node << domain_node('name', @name)
+        node
+      end
+    end
+  end
+end

data/lib/epp-client/domain/delete_response.rb

@@ -0,0 +1,9 @@
+require File.expand_path('../response', __FILE__)
+
+module EPP
+  module Domain
+    class DeleteResponse < Response
+      
+    end
+  end
+end

data/lib/epp-client/domain/info.rb

@@ -0,0 +1,21 @@
+require File.expand_path('../command', __FILE__)
+
+module EPP
+  module Domain
+    class Info < Command
+      def initialize(name)
+        @name = name
+      end
+
+      def name
+        'info'
+      end
+
+      def to_xml
+        node = super
+        node << domain_node('name', @name)
+        node
+      end
+    end
+  end
+end

data/lib/epp-client/domain/info_response.rb

@@ -0,0 +1,72 @@
+require File.expand_path('../response', __FILE__)
+
+module EPP
+  module Domain
+    class InfoResponse < Response
+      def name
+        @name ||= value_for_xpath('//domain:name')
+      end
+      def roid
+        @roid ||= value_for_xpath('//domain:roid')
+      end
+      def status
+        @status ||= values_for_xpath('//domain:status/@s')
+      end
+      def registrant
+        @registrant ||= value_for_xpath('//domain:registrant')
+      end
+      def contacts
+        @contacts ||= nodes_for_xpath('//domain:contact').inject({}) do |hash, node|
+          hash[node['type'].to_s] = node.content.strip
+          hash
+        end
+      end
+      def nameservers
+        @nameservers ||= nodes_for_xpath('//domain:ns').map do |ns_node|
+          ns = ns_node.find('domain:hostAttr', namespaces).map do |hostAttr|
+            name_node = hostAttr.find('domain:hostName').first
+            ipv4_node = hostAttr.find('domain:hostAddr[@ip="v4"]').first
+            ipv6_node = hostAttr.find('domain:hostAddr[@ip="v6"]').first
+
+            {}.tap do |result|
+              result['name']= name_node.content.strip if name_node
+              result['ipv4']= ipv4_node.content.strip if ipv4_node
+              result['ipv6']= ipv6_node.content.strip if ipv6_node
+            end
+          end
+
+          ns + ns_node.find('domain:hostObj').map { |n| { 'name' => n.content.strip } }
+        end.flatten
+      end
+      def hosts
+        @hosts ||= values_for_xpath('//domain:host')
+      end
+      def client_id
+        @clid ||= value_for_xpath('//domain:clID')
+      end
+      def creator_id
+        @crid ||= value_for_xpath('//domain:crID')
+      end
+      def created_date
+        @crdate ||= value_for_xpath('//domain:crDate') && Time.parse(value_for_xpath('//domain:crDate'))
+      end
+      def updator_id
+        @upid ||= value_for_xpath('//domain:upID')
+      end
+      def updated_date
+        @update ||= value_for_xpath('//domain:upDate') && Time.parse(value_for_xpath('//domain:upDate'))
+      end
+      def expiration_date
+        @exdate ||= value_for_xpath('//domain:exDate') && Time.parse(value_for_xpath('//domain:exDate'))
+      end
+      def transfer_date
+        @trdate ||= value_for_xpath('//domain:trDate') && Time.parse(value_for_xpath('//domain:trDate'))
+      end
+      def auth_info
+        @auth_info ||= begin
+          { 'pw' => value_for_xpath('//domain:authInfo/domain:pw') }
+        end
+      end
+    end
+  end
+end

data/lib/epp-client/domain/list.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../command', __FILE__)
+
+module EPP
+  module Domain
+    class List < Command
+      def initialize(expire_date)
+        @expire_date = expire_date
+      end
+
+      def name
+        'info'
+      end
+
+      def to_xml
+        @namespaces ||= {}
+        node = super
+        node << list_node
+        node
+      end
+
+      private
+
+      def list_node
+        node = xml_node('list')
+        node.namespaces.namespace = list_namespace(node)
+        node << xml_node('l:expiry', "#{@expire_date.year}-#{@expire_date.month}")
+        node
+      end
+
+      def list_namespace(node)
+        return @namespaces['l'] if @namespaces.has_key?('l')
+        @namespaces['l'] = xml_namespace(node, 'l', 'xmlns:l="http://www.nominet.org.uk/epp/xml/std-list-1.0')
+      end
+    end
+  end
+end

data/lib/epp-client/domain/renew.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../command', __FILE__)
+
+module EPP
+  module Domain
+    class Renew < Command
+      # @param [String] name Domain name to renew
+      # @param [Time,String] exp_date Expiration date of the domain
+      # @param [String] period Renewal period in XXy years or XXm months. XX must be between 1 and 99.
+      def initialize(name, exp_date, period = nil)
+        @name, @exp_date = name, exp_date
+        @exp_date = Time.parse(exp_date) if exp_date.kind_of?(String)
+
+        if period
+          @period_val, @period_unit = validate_period(period)
+        end
+      end
+
+      def name
+        'renew'
+      end
+
+      def to_xml
+        node = super
+        node << domain_node('name', @name)
+        node << domain_node('curExpDate', @exp_date.strftime("%Y-%m-%d"))
+
+        if @period_val && @period_unit
+          p = domain_node('period', @period_val)
+          p['unit'] = @period_unit
+
+          node << p
+        end
+
+        node
+      end
+    end
+  end
+end

data/lib/epp-client/domain/renew_response.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../response', __FILE__)
+
+module EPP
+  module Domain
+    class RenewResponse < Response
+      def name
+        @name ||= value_for_xpath('//domain:name')
+      end
+      def expiration_date
+        @date ||= value_for_xpath('//domain:exDate') && Time.parse(value_for_xpath('//domain:exDate'))
+      end
+    end
+  end
+end

data/lib/epp-client/domain/response.rb

@@ -0,0 +1,34 @@
+module EPP
+  module Domain
+    class Response
+      include ResponseHelper
+
+      def initialize(response)
+        @response = response
+      end
+
+      def method_missing(meth, *args, &block)
+        return super unless @response.respond_to?(meth)
+        @response.send(meth, *args, &block)
+      end
+
+      def respond_to_missing?(method, include_private)
+        @response.respond_to?(method, include_private)
+      end
+
+      unless RUBY_VERSION >= "1.9.2"
+        def respond_to?(method, include_private = false)
+          respond_to_missing?(method, include_private) || super
+        end
+        def method(sym)
+          respond_to_missing?(sym, true) ? @response.method(sym) : super
+        end
+      end
+
+      protected
+        def namespaces
+          {'domain' => NAMESPACE}
+        end
+    end
+  end
+end

data/lib/epp-client/domain/transfer.rb

@@ -0,0 +1,37 @@
+require File.expand_path('../command', __FILE__)
+
+module EPP
+  module Domain
+    class Transfer < Command
+      # @auth_info[:ext] should be an XML::Node with whatever is required
+      def initialize(name, period = nil, auth_info = {})
+        @name = name
+        @auth_info = auth_info
+        
+        if period
+          @period_val, @period_unit = validate_period(period)
+        end
+      end
+
+      def name
+        'transfer'
+      end
+
+      def to_xml
+        node = super
+        node << domain_node('name', @name)
+
+        if @period_val && @period_unit
+          p = domain_node('period', @period_val)
+          p['unit'] = @period_unit
+
+          node << p
+        end
+
+        node << auth_info_to_xml(@auth_info) unless @auth_info.empty?
+
+        node
+      end
+    end
+  end
+end

data/lib/epp-client/domain/transfer_response.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../response', __FILE__)
+
+module EPP
+  module Domain
+    class TransferResponse < Response
+      def name
+        @name ||= value_for_xpath('//domain:name')
+      end
+      def status
+        @trStatus ||= value_for_xpath('//domain:trStatus')
+      end
+      def requested_id
+        @reID ||= value_for_xpath('//domain:reID')
+      end
+      def requested_date
+        @reDate ||= value_for_xpath('//domain:reDate') && Time.parse(value_for_xpath('//domain:reDate'))
+      end
+      def expiration_date
+        @exDate ||= value_for_xpath('//domain:exDate') && Time.parse(value_for_xpath('//domain:exDate'))
+      end
+      def action_id
+        @acID ||= value_for_xpath('//domain:acID')
+      end
+      def action_date
+        @acDate ||= value_for_xpath('//domain:acDate') && Time.parse(value_for_xpath('//domain:acDate'))
+      end
+    end
+  end
+end