nominet-epp 0.0.12 → 1.0.0

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

@@ -1,84 +0,0 @@
-module NominetEPP
-  module Operations
-    # EPP Transfer Operation
-    module Transfer
-      # @overload transfer(:release, name, tag, to_account_id = nil)
-      #   @param [String] name Domain to release
-      #   @param [String] tag TAG to release the domain to
-      #   @param [String] to_account_id Specific account ID to release to
-      #   @return [Hash] +{:result => true|:handshake}+ if successfully transferred or pending
-      #   @return [false] transfer failed
-      # @overload transfer(:approve, case_id)
-      #   @param [String] case_id Transfer case to approve
-      #   @return [false] failed
-      #   @return [Hash] of +:case_id+ and array of +:domains+
-      # @overload transfer(:reject, case_id)
-      #   @param [String] case_id Transfer case to reject
-      #   @return [false] failed
-      #   @return [Hash] of +:case_id+ and array of +:domains+
-      # @param [Symbol] type Type of transfer operation
-      # @raise [ArgumentError] type is not one of +:release+, +:approve+ or +:reject+
-      # @see transfer_release
-      # @see transfer_approve
-      # @see transfer_reject
-      def transfer(type, *args)
-        raise ArgumentError, "type must be :release, :approve, :reject" unless [:release, :approve, :reject].include?(type)
-
-        @resp = @client.transfer do |transfer|
-          transfer['op'] = type.to_s
-          transfer << self.send(:"transfer_#{type}", *args)
-        end
-
-        if type == :release
-          case @resp.code
-          when 1000
-            { :result => true }
-          when 1001
-            { :result => :handshake }
-          else
-            false
-          end
-        else
-          return false unless @resp.success?
-          nCase, domainList = @resp.data
-          { :case_id => node_value(nCase,'//n:Case/n:case-id'),
-            :domains => domainList.find('//n:domain-name', namespaces).map{|n| n.content.strip} }
-        end
-      end
-
-      private
-        # @param [String] name Domain to release
-        # @param [String] tag TAG to release the domain to
-        # @param [String] to_account_id Specific account ID to release to
-        # @return [XML::Node] +domain:transfer+ payload 
-        def transfer_release(name, tag, to_account_id = nil)
-          domain('transfer') do |node, ns|
-            node << XML::Node.new('name', name, ns)
-            node << XML::Node.new('registrar-tag', tag, ns)
-
-            unless to_account_id.nil?
-              account = XML::Node.new('account', nil, ns)
-              account << XML::Node.new('account-id', to_account_id, ns)
-              node << account
-            end
-          end
-        end
-
-        # @param [String] case_id Transfer case to approve
-        # @return [XML::Node] +notification:case+ payload
-        def transfer_approve(case_id)
-          notification('Case') do |node, ns|
-            node << XML::Node.new('case-id', case_id, ns)
-          end
-        end
-
-        # @param [String] case_id Transfer case to reject
-        # @return [XML::Node] +notification:case+ payload
-        def transfer_reject(case_id)
-          notification('Case') do |node, ns|
-            node << XML::Node.new('case-id', case_id, ns)
-          end
-        end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-module NominetEPP
-  module Operations
-    # EPP Unlock Operation
-    module Unlock
-      # Unlock domain or account 'investigation' or 'opt-out'
-      #
-      # @param [Symbol] entity Entity to unlock
-      # @param [String] type Type of unlock
-      # @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] unlocking successful
-      def unlock(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:unlock+ 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:unlock+ element
-        def unlock_opt_out(entity, id)
-          account('unlock') do |node, ns|
-            node['type'] = 'opt-out'
-            node << XML::Node.new((entity == :domain ? 'domain-name' : 'roid'), id, ns)
-          end
-        end
-
-        # Create +unlock+ 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 unlock on
-        # @param [String] id Domain name or account ID to set unlock on
-        # @return [XML::Node] +lock+ element
-        def unlock_investigation(entity, id)
-          self.send(entity, 'unlock') 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/unrenew.rb

@@ -1,36 +0,0 @@
-module NominetEPP
-  module Operations
-    # EPP Unrenew Operation
-    module Unrenew
-      # Reverse a renewal request for one or more domain names.
-      #
-      # Unrenew commands will only be processed if the renewal invoice
-      # has not yet been generated. If the operation is successful, an
-      # email will be sent to the registrant of the domain name notifying
-      # them of the renewal reversal.
-      #
-      # @param [String, ...] *names Domain names to unrenew
-      # @return [false] unrenew failed
-      # @return [Hash<String, Time>] hash of domains and expiry times 
-      def unrenew(*names)
-        @resp = @client.update do
-          domain('unrenew') do |node, ns|
-            names.each do |name|
-              node << XML::Node.new('name', name, ns)
-            end
-          end
-        end
-
-        return false unless @resp.success?
-
-        hash = {}
-        @resp.data.find('//domain:renData', namespaces).each do |node|
-          renName = node_value(node, 'domain:name')
-          renExp  = node_value(node, 'domain:exDate')
-          hash[renName] = Time.parse(renExp)
-        end
-        hash
-      end
-    end
-  end
-end

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

@@ -1,176 +0,0 @@
-module NominetEPP
-  module Operations
-    # == EPP Update Operation
-    #
-    # === Domain Update
-    # The +id+ field for domain updates is the domain name to be modified.
-    #
-    # Fields options
-    # - (Hash) +:account+ -- Hash of account details to be updated
-    # - (String,Hash) +:ns+ -- Single or array of nameservers to set on the domain
-    # - (String) +:first_bill+ -- Set first-bill
-    # - (String) +:recur_bill+ -- Set recur-bill
-    # - (String) +:auto_bill+ -- Set auto-bill
-    # - (String) +:purchase_order+ -- Set purchase-oder
-    # - (String) +:notes+ -- Notes about the domain
-    # - (Boolean) +:renew_not_required+ -- Mark a domain as no longer needed
-    # - (String) +:reseller+ -- Set reseller
-    # ... etc ... any other permitted account fields
-    #
-    # === Account Update
-    # The +id+ field for account updates is the ROID identifying
-    # the account record on the remote endpoint.
-    #
-    # Fields options
-    # - (Array) +:contacts+ -- Array of contacts to create on the account
-    # - (Hash) +:addr+ -- Hash of address fields to modify on the account
-    # - (String) +:name+ -- Account holder name
-    # ... etc ... any other permitted account fields
-    #
-    # === Contact Update
-    # The +id+ field for contact updates is the ROID identifying
-    # the contact record on the remote endpoint.
-    #
-    # Fields options
-    # - (String) +:name+ -- Contacts new name
-    # - (String) +:email+ -- Contacts new email address
-    # - (String) +:phone+ -- Contacts new phone number
-    # - (String) +:mobile+ -- Contacts new mobile number
-    #
-    # === Nameserver Update
-    # The +id+ field for nameserver updates is the fully qualified
-    # hostname for the name server you wish to update.
-    #
-    # Fields options
-    # - (Hash) +:add+ -- Addresses to add to the nameserver
-    # - (Hash) +:rem+ -- Addresses to remove from the nameserver
-    # - (String) +:chg+ -- New hostname of the nameserver
-    #
-    # Fields +:add+ and +:rem+ options
-    # - (String) +:v4+ -- IPv4 address to add or remove from the nameserver
-    # - (String) +:v6+ -- IPv6 address to add or remove from the nameserver
-    #
-    # Example:
-    #
-    #     fields = {:chg => 'new.ns.example.com',
-    #               :add => {:v4 => '192.168.1.45', :v6 => '2001:db8::1'},
-    #               :rem => {:v4 => '192.168.1.14', :v6 => '2001:db8::b'}}
-    #
-    module Update
-      # @param [Symbol] entity Entity to update, one of domain, account, contact or nameserver
-      # @param [String] id Domain, Account, Contact or Nameserver to update
-      # @param [Hash] fields Fields to update
-      # @return [Boolean] request successful
-      def update(entity, id, fields = {})
-        @resp = @client.update do
-          self.send(:"update_#{entity}", id, fields)
-        end
-
-        return @resp.success?
-      end
-      private
-        # Generate +domain:update+ payload
-        # @param [String] name Domain name to update
-        # @param [Hash] fields Fields to update on the domain
-        # @return [XML::Node] +domain:update+ payload
-        def update_domain(name, fields)
-          keys = [:auto_period, :account, :ns, :first_bill, :recur_bill,
-            :auto_bill, :next_bill, :renew_not_required, :notes, :reseller]
-
-          domain('update') do |node, ns|
-            node << XML::Node.new('name', name, ns)
-            keys.each do |k|
-              next if fields[k].nil?
-              case k
-              when :account
-                node << (d_acct = XML::Node.new('account', nil, ns))
-                d_acct << account('update') do |acct, a_ns|
-                  account_update_xml(fields[k], acct, a_ns)
-                end
-              when :ns
-                node << domain_ns_xml(fields[k], ns)
-              else
-                node << generic_field_to_xml(k, fields[k], ns) unless fields[k] == ''
-              end
-            end
-          end
-        end
-
-        # Generate +account:update+ payload
-        # @param [String] roid Account ID
-        # @param [Hash] fields Fields to update on the account
-        # @return [XML::Node] +account:update+ payload
-        def update_account(roid, fields = {})
-          account('update') do |node, ns|
-            node << XML::Node.new('roid', roid, ns)
-            account_fields_xml(fields, node, ns)
-          end
-        end
-
-        # Generate +contact:update+ payload
-        # @param [String] roid Contact ID
-        # @param [Hash] fields Fields to update on the contact
-        # @raise [ArgumentError] invalid keys
-        # @return [XML::Node] XML +contact:update+ element
-        def update_contact(roid, fields = {})
-          contact_to_xml(fields.merge(:roid => roid))
-        end
-
-        # Generate +host:update+ payload to modify a nameserver entry
-        # ---
-        # We need to know nameserver old data as well.
-        # If we are changing the nameserver name and keeping the info the same
-        # then we do a host:chg. If we are adding an IPv{4,6} address we use
-        # the host:add wrapper, and to remove we do a host:rem. As Nominet only
-        # allow one IPv{4,6} address per nameserver we should remove the old
-        # IP address from the server before adding the one. Alternatively if
-        # Nominet will automatically drop previous address then we need only
-        # do a host:add call.
-        # +++
-        #
-        # Fields options
-        # - (Hash) +:add+ -- Addresses to add to the nameserver
-        # - (Hash) +:rem+ -- Addresses to remove from the nameserver
-        # - (String) +:chg+ -- New hostname of the nameserver
-        #
-        # Fields +:add+ and +:rem+ options
-        # - (String) +:v4+ -- IPv4 address to add or remove from the nameserver
-        # - (String) +:v6+ -- IPv6 address to add or remove from the nameserver
-        #
-        # @param [String] name Nameserver host to update
-        # @param [Hash] fields Nameserver update information
-        # @raise [ArgumentError] invalid keys, either on fields or fields[:add] or fields[:rem]
-        # @return [XML::Node] +host:update+ payload
-        def update_nameserver(name, fields = {})
-          raise ArgumentError, "allowed keys :add, :rem, :chg" unless (fields.keys - [:add, :rem, :chg]).empty?
-
-          host('update') do |node, ns|
-            node << XML::Node.new('name', name, ns)
-
-            if fields.has_key?(:add) && fields[:add].kind_of?(Hash)
-              raise ArgumentError, "allowed :add keys are :v4 and :v6" unless (fields[:add].keys - [:v4, :v6]).empty?
-              node << (add = XML::Node.new('add', nil, ns))
-              fields[:add].each do |k,v|
-                add << (n = XML::Node.new('addr', v, ns))
-                n['ip'] = k.to_s
-              end
-            end
-
-            if fields.has_key?(:rem) && fields[:rem].kind_of?(Hash)
-              raise ArgumentError, "allowed :rem keys are :v4 and :v6" unless (fields[:rem].keys - [:v4, :v6]).empty?
-              node << (rem = XML::Node.new('rem', nil, ns))
-              fields[:rem].each do |k,v|
-                rem << (n = XML::Node.new('addr', v, ns))
-                n['ip'] = k.to_s
-              end
-            end
-
-            if fields.has_key?(:chg) && fields[:chg].kind_of?(String)
-              node << (chg = XML::Node.new('chg', nil, ns))
-              chg << XML::Node.new('name', fields[:chg], ns)
-            end
-          end
-        end
-    end
-  end
-end