nominet-epp 0.0.12 → 1.0.0

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

@@ -1,138 +0,0 @@
-module NominetEPP
-  module Operations
-    # EPP Create Operation
-    module Create
-      # Register a domain name with Nominet.
-      #
-      # The returned hash has the following keys
-      # - (String) +:name+ --    Domain name registered
-      # - (Time) +:crDate+ --    Domain creation date
-      # - (Time) +:exDate+ --    Domain expiration date
-      # - (Hash) +:account+ --   Created account data (if returned)
-      #
-      # The +:account+ hash contains the following keys
-      # - (String) +:roid+ --    Account ID
-      # - (String) +:name+ --    Account Name
-      # - (Array) +:contacts+ -- Account contacts
-      #
-      # The +:contacts+ array contains hashes of the following keys
-      # - (String) +:roid+ --    Contact ID
-      # - (String) +:name+ --    Contact Name
-      # - (String) +:type+ --    Contact type if set
-      # - (Integer) +:order+ --  Contacts order in the list of contacts
-      #
-      # @param [String] name Domain name to register
-      # @param [String, Hash] acct
-      # @param [String, Array] nameservers Nameservers to set for the domain
-      # @param [Hash] options Registration options
-      # @option options [String] :period
-      # @option options [String] :first_bill
-      # @option options [String] :recur_bill
-      # @option options [String] :auto_bill
-      # @option options [String] :next_bill
-      # @option options [String] :notes
-      # @raise [ArgumentError] invalid option keys
-      # @return [false] registration failed
-      # @return [Hash] Domain creation data
-      def create(name, acct, nameservers, options = {})
-        raise ArgumentError, "options allowed keys are period, first_bill, recur_bill, auto_bill, next_bill, notes" unless (options.keys - [:period, :first_bill, :recur_bill, :auto_bill, :next_bill, :notes]).empty?
-
-        @resp = @client.create do
-          domain('create') do |node, ns|
-            node << XML::Node.new('name', name, ns)
-
-            if period = options.delete(:period)
-              unit = period[-1..1]
-              num = period.to_i.to_s
-              p = XML::Node.new('period', num, ns);
-              p['unit'] = unit
-              node << p
-            end
-
-            # node << XML::Node.new('auto-period', '', ns) # placeholder
-
-            node << XML::Node.new('account', nil, ns).tap do |acct_xml|
-              acct_xml << create_account(acct, ns)
-            end
-
-            node << domain_ns_xml(nameservers, ns)
-
-            # Enforce correct sequencing of option fields
-            [:first_bill, :recur_bill, :auto_bill, :next_bill, :notes].each do |key|
-              next if options[key].nil? || options[key] == ''
-              node << XML::Node.new(key.to_s.gsub('_', '-'), options[key], ns)
-            end
-          end
-        end
-
-        unless @resp.success?
-          @error_info = {
-            :name => node_value(@resp.data, '//domain:failData/domain:name/node()'),
-            :reason => node_value(@resp.data, '//domain:failData/domain:reason/node()') }
-          return false
-        end
-
-        creData = @resp.data.find('//domain:creData', namespaces).first
-        h = { :name => node_value(creData, 'domain:name'),
-          :crDate => Time.parse(node_value(creData, 'domain:crDate')),
-          :exDate => Time.parse(node_value(creData, 'domain:exDate')) }
-        unless creData.find('domain:account').first.nil?
-          h[:account] = created_account(creData.find('domain:account/account:creData', namespaces).first)
-        end
-        h
-      end
-      
-      private
-        # Create the account payload
-        #
-        # @param [String, Hash] acct Account ID or New account fields
-        # @param [XML::Namespace] domain_ns +:domain+ namespace
-        # @raise [ArgumentError] acct must be a String or a Hash of account fields
-        # @return [XML::Node]
-        def create_account(acct, domain_ns)
-          if acct.kind_of?(String)
-            XML::Node.new('account-id', acct, domain_ns)
-          elsif acct.kind_of?(Hash)
-            account('create') do |node, ns|
-              node << XML::Node.new('name', acct[:name], ns)
-              account_fields_xml(acct, node, ns)
-            end
-          else
-            raise ArgumentError, "acct must be String or Hash"
-          end
-        end
-
-        # Collects created account information
-        #
-        # @param [XML::Node] creData XML
-        # @return [Hash]
-        def created_account(creData)
-          { :roid => node_value(creData, 'account:roid'),
-            :name => node_value(creData, 'account:name'),
-            :contacts => created_contacts(creData.find(
-              'account:contact', namespaces)) }
-        end
-
-        # Collects created account contacts
-        #
-        # @param [XML::Node] account_contacts Account contacts
-        # @return [Hash]
-        def created_contacts(account_contacts)
-          account_contacts.map do |cont|
-            { :type => cont['type'],
-              :order => cont['order'] }.merge(
-                created_contact(cont.find('contact:creData', namespaces).first))
-          end
-        end
-
-        # Collects create contact information
-        #
-        # @param [XML::Node] creData XML
-        # @return [Hash]
-        def created_contact(creData)
-          { :roid => node_value(creData, 'contact:roid'),
-            :name => node_value(creData, 'contact:name') }
-        end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,64 +0,0 @@
-module NominetEPP
-  module Operations
-    # EPP Poll Operation
-    module Poll
-      # Error for indicating a failed poll ack response
-      class AckError < RuntimeError; end
-
-      # Poll the EPP server for events.
-      #
-      # If a block is given then it will be invoked once for
-      # each pending event. If no block is given the only the
-      # first received event will be returned along with the
-      # message ID of the event to allow the message to be
-      # ack'd. nil is returned if there is an error in the
-      # response or if there are not further messages to process.
-      #
-      # @example Without a block
-      #   msgID, xml = client.poll
-      #   ... process xml ...
-      #   client.ack(msgID)
-      #
-      # @example With a block
-      #   client.poll do |xml|
-      #     ... process xml ...
-      #   end
-      #
-      # @yield [data] process data if messages to poll
-      # @yieldparam [XML::Node] data Response data
-      # @return [nil] no messages to handle
-      # @return [Array<String,XML::Node>] message ID and response xml data
-      # @raise [AckError] ack of event notification failed
-      # @see ack
-      def poll
-        while resp = poll_req
-          return if resp.code != 1301 || resp.msgQ['count'] == '0'
-          return [resp.msgQ['id'], resp.data] unless block_given?
-
-          yield resp.data
-          raise AckError, "failed to acknowledge message #{resp.msgQ['id']}" unless ack(resp.msgQ['id'])
-        end
-      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
-
-      protected
-        def poll_req
-          @client.poll do |poll|
-            poll['op'] = 'req'
-          end
-        end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-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