nominet-epp 0.0.2

data/lib/nominet-epp/operations/delete.rb

@@ -0,0 +1,20 @@
+module NominetEPP
+  module Operations
+    # EPP Delete Operation
+    module Delete
+      # Delete a domain from the registry
+      #
+      # @param [String] name Domain name
+      # @return [Boolean] success status
+      def delete(name)
+        resp = @client.delete do
+          domain('delete') do |node, ns|
+            node << XML::Node.new('name', name, ns)
+          end
+        end
+
+        resp.success?
+      end
+    end
+  end
+end

data/lib/nominet-epp/operations/fork.rb

@@ -0,0 +1,53 @@
+module NominetEPP
+  module Operations
+    # EPP Fork Operation
+    module Fork
+      # Splits a selection of domains from one account into another.
+      #
+      # The returned hash contains the following keys
+      # - (String) +:roid+ -- New account ID
+      # - (String) +:name+ -- New account name
+      # - (String) +:crDate+ -- Date the account was created
+      # - (Hash) +:contact+ -- Contact details
+      #
+      # The +:contact+ hash contains the following keys
+      # - (String) +:roid+ -- Contact ID
+      # - (String) +:name+ -- Contact Name
+      # - (String) +:type+ -- Contact Type
+      # - (Integer) +:order+ -- Contact Order
+      #
+      # @param [String] account_num Account Number
+      # @param [String, ...] *names Domain names to fork from the account
+      # @return [false] fork failed
+      # @return [Hash] new account details
+      def fork(account_num, *names)
+        resp = @client.update do
+          account('fork') do |node, ns|
+            node << XML::Node.new('roid', account_num, ns)
+            names.each do |name|
+              node << XML::Node.new('domain-name', name, ns)
+            end
+          end
+        end
+
+        return false unless resp.success?
+
+        hash = {
+          :roid => node_value(resp.data, '//account:creData/account:roid'),
+          :name => node_value(resp.data, '//account:creData/account:name'),
+          :crDate => node_value(resp.data, '//account:creData/account:crDate'),
+          :contact => {
+            :roid => node_value(resp.data, '//account:creData/account:contact/contact:creData/contact:roid'),
+            :name => node_value(resp.data, '//account:creData/account:contact/contact:creData/contact:name')
+          }
+        }
+
+        contact = resp.data.find('//account:creData/account:contact', namespaces).first
+        hash[:contact][:type] = contact['type']
+        hash[:contact][:order] = contact['order']
+
+        hash
+      end
+    end
+  end
+end

data/lib/nominet-epp/operations/hello.rb

@@ -0,0 +1,11 @@
+module NominetEPP
+  module Operations
+    # EPP Hello Operation
+    module Hello
+      # @return [Boolean] hello greeting returned
+      def hello
+        @client.hello  # This should be a epp-client method
+      end
+    end
+  end
+end

data/lib/nominet-epp/operations/info.rb

@@ -0,0 +1,93 @@
+module NominetEPP
+  module Operations
+    # EPP Info Operation
+    module Info
+      # @param [Symbol] entity Type of entity to get information about
+      # @param [String] id Identifier of the entity
+      # @return [false] failed
+      # @return [Hash]
+      def info(entity, id)
+        raise ArgumentError, "entity must be :domain, :contact or :account" unless [:domain, :contact, :account].include?(entity)
+
+        resp = @client.info do
+          case entity
+          when :domain
+            domain('info') { |node, ns| node << XML::Node.new('name', id, ns) }
+          when :account
+            account('info') { |node, ns| node << XML::Node.new('roid', id, ns) }
+          when :contact
+            contact('info') { |node, ns| node << XML::Node.new('roid', id, ns) }
+          end
+        end
+
+        return false unless resp.success?
+        self.send(:"info_#{entity}", resp.data)
+      end
+
+      private
+        # @param [XML::Node] data Domain data
+        # @return [Hash]
+        def info_domain(data)
+          hash = {}
+          data.find('//domain:infData', namespaces).first.children.reject{|n| n.empty?}.each do |node|
+            key = node.name.gsub('-', '_').to_sym
+            case node.name
+            when 'account'
+              hash[:account] = info_account(node)
+            when 'ns'
+              hash[:ns] = node.find('domain:host', namespaces).map do |hostnode|
+                { :name => node_value(hostnode, 'domain:hostName'),
+                  :v4 => node_value(hostnode, 'domain:hostAddr[@ip="v4"]'),
+                  :v6 => node_value(hostnode, 'domain:hostAddr[@ip="v6"]') }.reject{|k,v| v.nil?}
+              end
+            when /date/i
+              hash[key] = Time.parse(node.content.strip)
+            else
+              hash[key] = node.content.strip
+            end
+          end
+          hash
+        end
+
+        # @param [XML::Node] data Account data
+        # @return [Hash]
+        def info_account(data)
+          hash = {}
+          data.find('//account:infData', namespaces).first.children.reject{|n| n.empty?}.each do |node|
+            key = node.name.gsub('-', '_').to_sym
+            case node.name
+            when 'addr'
+              hash[:addr] = {}
+              node.children.reject{|n| n.empty?}.each do |n|
+                hash[:addr][n.name.to_sym] = n.content.strip
+              end
+            when 'contact'
+              hash[:contacts] ||= Array.new
+              hash[:contacts] << info_contact(node)
+              hash[:contacts].last[:type] = node['type']
+              hash[:contacts].last[:order] = node['order']
+            when /date/i
+              hash[key] = Time.parse(node.content.strip)
+            else
+              hash[key] = node.content.strip
+            end
+          end
+          hash
+        end
+
+        # @param [XML::Node] data Contact data
+        # @return [Hash]
+        def info_contact(data)
+          hash = {}
+          data.find('//contact:infData', namespaces).first.children.reject{|n| n.empty?}.each do |node|
+            if node.name =~ /date/i
+              hash[node.name.to_sym] = Time.parse(node.content.strip)
+            else
+              hash[node.name.to_sym] = node.content.strip
+            end
+          end
+          hash
+        end
+    end
+  end
+end

data/lib/nominet-epp/operations/list.rb

@@ -0,0 +1,83 @@
+module NominetEPP
+  module Operations
+    # EPP List Operatons
+    module List
+      # Obtain a list of domains, and optionally their details, which either
+      # expire or were registered in the month given.
+      #
+      # @param [Symbol] type Listing type, either +:expiry+ or +:month+
+      # @param [String, #strftime] date Date of either expiry or registration to list
+      # @param [String] fields Verbosity of the response, either 'none' or 'all'
+      # @raise [ArgumentError] type must be +:expiry+ or +:month+
+      # @return [nil] list failed
+      # @return [Array<String>] list of domains
+      # @return [Array<Hash>] list of domains with details
+      def list(type, date, fields = 'none')
+        raise ArgumentError, "type must be :expiry or :month" unless [:expiry, :month].include?(type)
+
+        date = date.strftime("%Y-%m") if date.respond_to?(:strftime)
+        resp = @client.info do
+          domain('list') do |node, ns|
+            node << XML::Node.new(type, date, ns)
+            node << XML::Node.new('fields', fields, ns)
+          end
+        end
+
+        return nil unless resp.success?
+
+        if fields == 'none'
+          resp.data.find('//domain:name', namespaces).map do |node|
+            node.content.strip
+          end
+        else
+          resp.data.find('//domain:infData', namespaces).map do |infData|
+            hash = {}
+            infData.children.reject{|n| n.empty?}.each do |node|
+              key = node.name.gsub('-', '_').to_sym
+              case node.name
+              when 'account'
+                hash[:account] = info_account(node)
+              when 'ns'
+                hash[:ns] = node.find('domain:host', namespaces).map do |hostnode|
+                  { :name => node_value(hostnode, 'domain:hostName'),
+                    :v4 => node_value(hostnode, 'domain:hostAddr[@ip="v4"]'),
+                    :v6 => node_value(hostnode, 'domain:hostAddr[@ip="v6"]') }.reject{|k,v| v.nil?}
+                end
+              when /date/i
+                hash[key] = Time.parse(node.content.strip)
+              else
+                hash[key] = node.content.strip
+              end
+            end
+            hash
+          end
+        end
+      end
+
+      # list of all tags that accept tag changes along with their handshake settings
+      #
+      # The returned array of hashes contain the following keys
+      # - (String) +:registrar_tag+ -- TAG name
+      # - (String) +:name+ -- Name of the TAG owner
+      # - (String) +:trad_name+ -- TAG trading name
+      # - (BOOL) +:handshake+ -- Whether the TAG accepts handshakes
+      #
+      # @return [false] failure
+      # @return [Array<Hash>] tag details
+      def tag_list
+        resp = @client.info do
+          tag('list')
+        end
+
+        return false unless resp.success?
+
+        resp.data.find('//tag:infData', namespaces).map do |node|
+          { :registrar_tag => node_value(node, 'tag:registrar-tag'),
+            :name =>          node_value(node, 'tag:name'),
+            :trad_name =>     node_value(node, 'tag:trad-name'),
+            :handshake =>     node_value(node, 'tag:handshake') == 'Y' }
+        end
+      end
+    end
+  end
+end

data/lib/nominet-epp/operations/lock.rb

@@ -0,0 +1,56 @@
+module NominetEPP
+  module Operations
+    # EPP Lock Operation
+    module Lock
+      # Lock domain or account 'investigation' or 'opt-out'
+      #
+      # @param [Symbol] entity Entity to lock
+      # @param [String] type Type of lock to set
+      # @param [String] id Domain name or account ID
+      # @raise [ArgumentError] entity is not +:domain+ or +:account+
+      # @raise [ArgumentError] type is not 'investigation' or 'opt-out'
+      # @return [Boolean] locking successful
+      def lock(entity, type, id)
+        raise ArgumentError, "entity must be :domain or :account" unless [:domain, :account].include?(entity)
+        raise ArgumentError, "type must be 'investigation' or 'opt-out'" unless %w(investigation opt-out).include?(type)
+
+        resp = @client.update do
+          case type
+          when 'investigation'
+            lock_investigation(entity, id)
+          when 'opt-out'
+            lock_opt_out(entity, id)
+          end
+        end
+
+        return resp.success?
+      end
+      private
+        # Create +account:lock+ XML element for opt-out lock
+        # @param [Symbol] entity Entity to set opt out lock on
+        # @param [String] id Domain name or Account ID to lock
+        # @return [XML::Node] +account:lock+ element
+        def lock_opt_out(entity, id)
+          account('lock') do |node, ns|
+            node['type'] = 'opt-out'
+            node << XML::Node.new((entity == :domain ? 'domain-name' : 'roid'), id, ns)
+          end
+        end
+
+        # Create +lock+ XML element for investigation lock
+        #
+        # We don't support 'investigation' on account:domain-name as this ability
+        # is already provided via domain:name
+        #
+        # @param [Symbol] entity Entity to set investigation lock on
+        # @param [String] id Domain name or account ID to set lock on
+        # @return [XML::Node] +lock+ element
+        def lock_investigation(entity, id)
+          self.send(entity, 'lock') do |node, ns|
+            node['type'] = 'investigation'
+            node << XML::Node.new((entity == :domain ? 'name' : 'roid'), id, ns)
+          end
+        end
+    end
+  end
+end

data/lib/nominet-epp/operations/merge.rb

@@ -0,0 +1,41 @@
+module NominetEPP
+  module Operations
+    # EPP Merge Operation
+    module Merge
+      # Merge accounts or domains into an Account
+      #
+      # @param [String] target Account ID to merge into
+      # @param [Hash] sources Account IDs to merge into the target
+      # @option sources [Array] :accounts Account numbers to merge
+      # @option sources [Array] :names Account names to merge
+      # @option sources [Array] :domains Domain names to merge
+      # @return [false] merge failed
+      # @return [Response] merge succeded
+      def merge(target, sources = {})
+        resp = @client.update do
+          account('merge') do |node, ns|
+            node << XML::Node.new('roid', target, ns)
+
+            (sources[:accounts] || []).each do |acct|
+              n = XML::Node.new('roid', acct, ns)
+              n['source'] = 'y'
+              node << n
+            end
+
+            (sources[:names] || []).each do |name|
+              node << XML::Node.new('name', name, ns)
+            end
+
+            (sources[:domains] || []).each do |domain|
+              node << XML::Node.new('domain-name', domain, ns)
+            end
+          end
+        end
+
+        return false unless resp.success?
+
+        resp  # Need to test this to see what gets returned
+      end
+    end
+  end
+end

data/lib/nominet-epp/operations/poll.rb

@@ -0,0 +1,38 @@
+module NominetEPP
+  module Operations
+    # EPP Poll Operation
+    module Poll
+      # Poll the EPP server for events
+      #
+      # @yield [data] process data if messages to poll
+      # @yieldparam [XML::Node] data Response data
+      # @return [nil] no messages to handle
+      # @return [Boolean] ack successful
+      # @see ack
+      def poll
+        resp = @client.poll do |poll|
+          poll['op'] = 'req'
+        end
+
+        return if resp.code != 1301 || resp.msgQ['count'] == '0'
+
+        yield resp.data
+
+        ack(resp.msgQ['id'])
+      end
+
+      # Acknowledges a polled message ID
+      #
+      # @param [String] msgID Message ID to acknowledge
+      # @return [Boolean] ack successful
+      def ack(msgID)
+        resp = @client.poll do |poll|
+          poll['op'] = 'ack'
+          poll['msgID'] = msgID
+        end
+
+        return resp.success?
+      end
+    end
+  end
+end

data/lib/nominet-epp/operations/renew.rb

@@ -0,0 +1,40 @@
+module NominetEPP
+  module Operations
+    # EPP Renew Operation
+    module Renew
+      # Renew a domain name
+      #
+      # @param [String] name Domain name to renew
+      # @param [String] period Length of time to renew for. Currently has to be '2y'.
+      # @raise [ArgumentError] invalid period specified
+      # @raise [RuntimeError] renewed domain name does not match +name+
+      # @return [false] renewal failed
+      # @return [Time] domain expiration date
+      def renew(name, period = '2y')
+        period = '2y'  # reset period to 2 years as nominet don't currently support other options
+
+        unit = period[-1..1]
+        num = period.to_i.to_s
+
+        raise ArgumentError, "period suffix must either be 'm' or 'y'" unless %w(m y).include?(unit)
+
+        resp = @client.renew do
+          domain('renew') do |node, ns|
+            node << XML::Node.new('name', name, ns)
+            p = XML::Node.new('period', num, ns);
+            p['unit'] = unit
+            node << p
+          end
+        end
+
+        return false unless resp.success?
+
+        renName = node_value(resp.data, '//domain:renData/domain:name')
+        renExp  = node_value(resp.data, '//domain:renData/domain:exDate')
+
+        raise "Renewed name #{renName} does not match #{name}" if renName != name
+        return Time.parse(renExp)
+      end
+    end
+  end
+end