dnsimple 2.2.0 → 3.0.0.pre.beta1

data/lib/dnsimple/client/domains_email_forwards.rb

@@ -0,0 +1,107 @@
+module Dnsimple
+  class Client
+    module DomainsEmailForwards
+
+      # Lists the email forwards for the domain.
+      #
+      # @see https://developer.dnsimple.com/v2/domains/email-forwards/#list
+      #
+      # @example List email forwards in the first page
+      #   client.domains.email_forwards(1010, "example.com")
+      #
+      # @example List email forwards, provide a specific page
+      #   client.domains.email_forwards(1010, "example.com", query: { page: 2 })
+      #
+      # @param  [Fixnum, Dnsimple::Client::WILDCARD_ACCOUNT] account_id the account ID or wildcard
+      # @param  [#to_s] domain_id The domain ID or domain name
+      # @param  [Hash] options the filtering and sorting option
+      # @return [Dnsimple::PaginatedResponse<Dnsimple::Struct::EmailForward>]
+      #
+      # @raise  [Dnsimple::NotFoundError]
+      # @raise  [Dnsimple::RequestError]
+      def email_forwards(account_id, domain_id, options = {})
+        response = client.get(Client.versioned("/%s/domains/%s/email_forwards" % [account_id, domain_id]), options)
+
+        Dnsimple::PaginatedResponse.new(response, response["data"].map { |r| Struct::EmailForward.new(r) })
+      end
+
+      # Lists ALL the email forwards for the domain.
+      #
+      # This method is similar to {#email_forwards}, but instead of returning the results of a specific page
+      # it iterates all the pages and returns the entire collection.
+      #
+      # Please use this method carefully, as fetching the entire collection will increase the number of requests
+      # you send to the API server and you may eventually risk to hit the throttle limit.
+      #
+      # @see https://developer.dnsimple.com/v2/domains/email-forwards/#list
+      # @see #email_forwards
+      #
+      # @param  [Fixnum, Dnsimple::Client::WILDCARD_ACCOUNT] account_id the account ID or wildcard
+      # @param  [#to_s] domain_id The domain ID or domain name
+      # @param  [Hash] options the filtering and sorting option
+      # @return [Dnsimple::CollectionResponse<Dnsimple::Struct::EmailForward>]
+      #
+      # @raise  [Dnsimple::RequestError]
+      def all_email_forwards(account_id, domain_id, options = {})
+        paginate(:email_forwards, account_id, domain_id, options)
+      end
+
+      # Creates an email forward for the domain.
+      #
+      # @see https://developer.dnsimple.com/v2/domains/email-forwards/#create
+      #
+      # @param  [Fixnum, Dnsimple::Client::WILDCARD_ACCOUNT] account_id the account ID or wildcard
+      # @param  [#to_s] domain_id The domain ID or domain name
+      # @param  [Hash] attributes
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<Dnsimple::Struct::EmailForward>]
+      #
+      # @raise  [Dnsimple::RequestError]
+      def create_email_forward(account_id, domain_id, attributes, options = {})
+        Extra.validate_mandatory_attributes(attributes, [:from, :to])
+        response = client.post(Client.versioned("/%s/domains/%s/email_forwards" % [account_id, domain_id]), attributes, options)
+
+        Dnsimple::Response.new(response, Struct::EmailForward.new(response["data"]))
+      end
+
+      # Gets a email forward for the domain.
+      #
+      # @see https://developer.dnsimple.com/v2/domains/email-forwards/#get
+      #
+      # @param  [Fixnum, Dnsimple::Client::WILDCARD_ACCOUNT] account_id the account ID or wildcard
+      # @param  [#to_s] domain_id The domain ID or domain name
+      # @param  [#to_s] email_forward_id The email forward ID
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<Dnsimple::Struct::EmailForward>]
+      #
+      # @raise  [Dnsimple::NotFoundError]
+      # @raise  [Dnsimple::RequestError]
+      def email_forward(account_id, domain_id, email_forward_id, options = {})
+        response = client.get(Client.versioned("/%s/domains/%s/email_forwards/%s" % [account_id, domain_id, email_forward_id]), options)
+
+        Dnsimple::Response.new(response, Struct::EmailForward.new(response["data"]))
+      end
+
+      # Deletes an email forward for the domain.
+      #
+      # WARNING: this cannot be undone.
+      #
+      # @see https://developer.dnsimple.com/v2/domains/email-forwards/#delete
+      #
+      # @param  [Fixnum, Dnsimple::Client::WILDCARD_ACCOUNT] account_id the account ID or wildcard
+      # @param  [#to_s] domain_id The domain ID or domain name
+      # @param  [#to_s] email_forward_id The email forward ID
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<nil>]
+      #
+      # @raise  [Dnsimple::NotFoundError]
+      # @raise  [Dnsimple::RequestError]
+      def delete_email_forward(account_id, domain_id, email_forward_id, options = {})
+        response = client.delete(Client.versioned("/%s/domains/%s/email_forwards/%s" % [account_id, domain_id, email_forward_id]), nil, options)
+
+        Dnsimple::Response.new(response, nil)
+      end
+
+    end
+  end
+end

data/lib/dnsimple/client/identity.rb

@@ -0,0 +1,38 @@
+module Dnsimple
+  class Client
+    module Identity
+
+      # Gets the information about the current authenticated context.
+      #
+      # @see https://developer.dnsimple.com/v2/identity/#whoami
+      #
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<Hash>]
+      # @raise  [Dnsimple::RequestError]
+      def whoami(options = {})
+        response = client.get(Client.versioned("/whoami"), options)
+
+        data = response["data"]
+        account = data["account"] ? Struct::Account.new(data["account"]) : nil
+        user = data["user"] ? Struct::User.new(data["user"]) : nil
+        Response.new(response, { account: account, user: user })
+      end
+
+
+      module StaticHelpers
+        # Calls {Identity#whoami} and directly returns the response data.
+        #
+        # @see https://developer.dnsimple.com/v2/identity/#whoami
+        #
+        # @param  [Dnsimple::Client] client the DNSimple client instance to use
+        # @param  [Array] args the args for the {Identity#whoami} call
+        # @return [Hash]
+        # @raise  [Dnsimple::RequestError]
+        def whoami(client, *args)
+          client.identity.whoami(*args).data
+        end
+      end
+
+    end
+  end
+end

data/lib/dnsimple/client/oauth.rb

@@ -0,0 +1,42 @@
+module Dnsimple
+  class Client
+    module Oauth
+
+      # Exchange the short-lived authorization code for an access token
+      # you can use to authenticate your API calls.
+      #
+      # @see https://developer.dnsimple.com/v2/oauth/
+      #
+      # @param  client_id [String] Client Id you received when the application was registered with DNSimple.
+      # @param  client_secret [String] Client Secret you received when the application was registered with DNSimple.
+      # @option options [String] :redirect_uri The redirect URL sent for the authorization, used to validate the request.
+      # @return [String] The url to redirect the user to authorize.
+      def exchange_authorization_for_token(code, client_id, client_secret, options = {})
+        attributes = { code: code, client_id: client_id, client_secret: client_secret, grant_type: "authorization_code" }
+        response = client.post(Client.versioned("/oauth/access_token"), attributes, options)
+        Struct::OauthToken.new(response)
+      end
+
+      # Gets the URL to authorize an user for an application via the OAuth2 flow.
+      #
+      # @see https://developer.dnsimple.com/v2/oauth/
+      #
+      # @param  client_id [String] Client Id you received when the application was registered with DNSimple.
+      # @option options [String] :redirect_uri The URL to redirect to after authorizing.
+      # @option options [String] :scope The scopes to request from the user.
+      # @option options [String] :state A random string to protect against CSRF.
+      # @return [String] The URL to redirect the user to authorize.
+      def authorize_url(client_id, options = {})
+        site_url = client.base_url.sub("api.", "")
+        url = URI.join(site_url, "/oauth/authorize?client_id=#{client_id}")
+
+        options = options.merge(response_type: "code")
+        options.each do |key, value|
+          url.query += "&#{key}=#{value}"
+        end
+        url.to_s
+      end
+
+    end
+  end
+end

data/lib/dnsimple/client/registrar.rb

@@ -2,119 +2,111 @@ module Dnsimple
   class Client
     module Registrar
 
-      # Checks the availability of a domain name.
+      # Checks whether a domain is available to be registered.
       #
-      # @see http://developer.dnsimple.com/v1/domains/registry/#check
+      # @see https://developer.dnsimple.com/v2/registrar/#check
       #
-      # @param  [#to_s] name The domain name to check.
-      # @return [Hash] The response containing the status, price, and more details.
+      # @example Check whether example.com is available:
+      #   client.registrar.check(1010, "example.com")
       #
-      # @raise  [RequestError] When the request fails.
-      def check(name, options = {})
-        response = begin
-          client.get(Client.versioned("/domains/#{name}/check"), options)
-        rescue NotFoundError => e
-          e.response
-        end
-
-        response.parsed_response
-      end
-
-      # Checks the availability of a domain name.
-      #
-      # @see http://developer.dnsimple.com/v1/domains/registry/#check
-      #
-      # @param  [#to_s] name The domain name to check.
-      # @return [Boolean] true if the domain is available
+      # @param  [Fixnum] account_id the account ID
+      # @param  [#to_s] domain_name the domain name to check
+      # @param  [Hash] options
+      # @return [Struct::DomainCheck]
       #
       # @raise  [RequestError] When the request fails.
-      def available?(name, options = {})
-        check(name, options)["status"] == "available"
+      def check_domain(account_id, domain_name, options = {})
+        endpoint = Client.versioned("/%s/registrar/domains/%s/check" % [account_id, domain_name])
+        response = client.get(endpoint, options)
+
+        Dnsimple::Response.new(response, Struct::DomainCheck.new(response["data"]))
       end
 
       # Registers a domain.
       #
-      # @see http://developer.dnsimple.com/v1/domains/registry/#register
+      # @see https://developer.dnsimple.com/v2/registrar/#register
+      #
+      # @example Initiate the registration of example.com using the contact 1234 as registrant
+      #   including WHOIS privacy for the domain and enabling auto renewal:
+      #   client.registrar.register(1010, "example.com", registrant_id: 1234, privacy: true, auto_renew: true)
       #
-      # @param  [#to_s] name The domain name to register.
-      # @param  [Fixnum] registrant_id The id of the contact to use as registrant.
-      # @param  [Hash] extended_attributes
+      # @param  [Fixnum] account_id the account ID
+      # @param  [#to_s] domain_name the domain name to register
+      # @param  [Hash] attributes
       # @param  [Hash] options
       # @return [Struct::Domain]
       #
       # @raise  [RequestError] When the request fails.
-      def register(name, registrant_id, extended_attributes = {}, options = {})
-        options = Extra.deep_merge(options, { domain: { name: name, registrant_id: registrant_id }, extended_attribute: extended_attributes })
-        response = client.post(Client.versioned("/domain_registrations"), options)
+      def register_domain(account_id, domain_name, attributes, options = {})
+        Extra.validate_mandatory_attributes(attributes, [:registrant_id])
+        endpoint = Client.versioned("/%s/registrar/domains/%s/registration" % [account_id, domain_name])
+        response = client.post(endpoint, attributes, options)
 
-        Struct::Domain.new(response["domain"])
+        Dnsimple::Response.new(response, Struct::Domain.new(response["data"]))
       end
 
-      # Transfers a domain.
+      # Renews a domain.
       #
-      # @see http://developer.dnsimple.com/v1/domains/registry/#transfer
+      # @see https://developer.dnsimple.com/v2/registrar/#renew
       #
-      # @param  [#to_s] name The domain name to register.
-      # @param  [String] auth_code
-      # @param  [Fixnum] registrant_id The id of the contact to use as registrant.
-      # @param  [Hash] extended_attributes
+      # @example Renew example.com for 3 years:
+      #   client.registrar.renew(1010, "example.com", period: 3)
+      #
+      # @param  [Fixnum] account_id the account ID
+      # @param  [#to_s] domain_name the domain name to renew
+      # @param  [Hash] attributes
       # @param  [Hash] options
-      # @return [Struct::TransferOrder]
+      # @return [Struct::Domain]
       #
       # @raise  [RequestError] When the request fails.
-      def transfer(name, auth_code, registrant_id, extended_attributes = {}, options = {})
-        options = Extra.deep_merge(options, { domain: { name: name, registrant_id: registrant_id }, extended_attribute: extended_attributes, transfer_order: { authinfo: auth_code }})
-        response = client.post(Client.versioned("/domain_transfers"), options)
+      def renew_domain(account_id, domain_name, attributes = nil, options = {})
+        endpoint = Client.versioned("/%s/registrar/domains/%s/renew" % [account_id, domain_name])
+        response = client.post(endpoint, attributes, options)
 
-        Struct::TransferOrder.new(response["transfer_order"])
+        Dnsimple::Response.new(response, Struct::Domain.new(response["data"]))
       end
 
-      # Renew a domain.
+      # Starts the transfer of a domain to DNSimple.
       #
-      # @see http://developer.dnsimple.com/v1/domains/registry/#renew
+      # @see https://developer.dnsimple.com/v2/registrar/#transfer
       #
-      # @param  [#to_s] name The domain name to renew.
+      # @example Initiate the transfer for example.com using the contact 1234 as registrant:
+      #   client.registrar.transfer(1010, "example.com", registrant_id: 1234, auth_info: "x1y2z3")
+      #
+      # @param  [Fixnum] account_id the account ID
+      # @param  [#to_s] domain_name the domain name to transfer
+      # @param  [Hash] attributes
       # @param  [Hash] options
       # @return [Struct::Domain]
       #
       # @raise  [RequestError] When the request fails.
-      def renew(name, options = {})
-        options = Extra.deep_merge(options, { domain: { name: name }})
-        response = client.post(Client.versioned("/domain_renewals"), options)
+      def transfer_domain(account_id, domain_name, attributes, options = {})
+        Extra.validate_mandatory_attributes(attributes, [:registrant_id])
+        endpoint = Client.versioned("/%s/registrar/domains/%s/transfer" % [account_id, domain_name])
+        response = client.post(endpoint, attributes, options)
 
-        Struct::Domain.new(response["domain"])
+        Dnsimple::Response.new(response, Struct::Domain.new(response["data"]))
       end
 
-
-      # List the extended attributes for a TLD.
-      #
-      # @see http://developer.dnsimple.com/v1/registrar/extended-attributes/#list
+      # Requests the transfer of a domain out of DNSimple.
       #
-      # @param  [#to_s] tld The TLD name.
-      # @return [Array<Struct::ExtendedAttribute>]
-      #
-      # @raise  [RequestError] When the request fails.
-      def extended_attributes(tld, options = {})
-        response = client.get(Client.versioned("/extended_attributes/#{tld}"), options)
-
-        response.map { |r| Struct::ExtendedAttribute.new(r) }
-      end
-      alias :list_extended_attributes :extended_attributes
-
-      # List all the TLD prices.
+      # @see https://developer.dnsimple.com/v2/registrar/#transfer_out
       #
-      # @see http://developer.dnsimple.com/v1/registrar/prices/#list
+      # @example Request to transfer of example.com out of DNSimple:
+      #   client.registrar.transfer_out(1010, "example.com")
       #
-      # @return [Array<Struct::Price>]
+      # @param  [Fixnum] account_id the account ID
+      # @param  [#to_s] domain_name the domain name to transfer out
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<nil>]
       #
       # @raise  [RequestError] When the request fails.
-      def prices(options = {})
-        response = client.get(Client.versioned("/prices"), options)
+      def transfer_domain_out(account_id, domain_name, options = {})
+        endpoint = Client.versioned("/%s/registrar/domains/%s/transfer_out" % [account_id, domain_name])
+        response = client.post(endpoint, nil, options)
 
-        response.map { |r| Struct::Price.new(r["price"]) }
+        Dnsimple::Response.new(response, nil)
       end
-      alias :list_prices :prices
-
     end
   end
 end

data/lib/dnsimple/client/registrar_auto_renewal.rb

@@ -0,0 +1,41 @@
+module Dnsimple
+  class Client
+    module RegistrarAutoRenewal
+
+      # Enable auto renewal for the domain in the account.
+      #
+      # @see https://developer.dnsimple.com/v2/registrar/auto-renewal/
+      #
+      # @param  [Fixnum, Dnsimple::Client::WILDCARD_ACCOUNT] account_id the account ID or wildcard
+      # @param  [#to_s] domain_name the domain name
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<nil>]
+      #
+      # @raise  [Dnsimple::NotFoundError]
+      # @raise  [Dnsimple::RequestError]
+      def enable_auto_renewal(account_id, domain_name, options={})
+        response = client.put(Client.versioned("/%s/registrar/domains/%s/auto_renewal" % [account_id, domain_name]), nil, options)
+
+        Dnsimple::Response.new(response, nil)
+      end
+
+      # Disable auto renewal for the domain in the account.
+      #
+      # @see https://developer.dnsimple.com/v2/registrar/auto-renewal/
+      #
+      # @param  [Fixnum, Dnsimple::Client::WILDCARD_ACCOUNT] account_id the account ID or wildcard
+      # @param  [#to_s] domain_name the domain name
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<nil>]
+      #
+      # @raise  [Dnsimple::NotFoundError]
+      # @raise  [Dnsimple::RequestError]
+      def disable_auto_renewal(account_id, domain_name, options={})
+        response = client.delete(Client.versioned("/%s/registrar/domains/%s/auto_renewal" % [account_id, domain_name]), nil, options)
+
+        Dnsimple::Response.new(response, nil)
+      end
+
+    end
+  end
+end

data/lib/dnsimple/client/registrar_whois_privacy.rb

@@ -0,0 +1,74 @@
+module Dnsimple
+  class Client
+    module RegistrarWhoisPrivacy
+
+      # Gets the whois privacy for the domain.
+      #
+      # @see https://developer.dnsimple.com/v2/registrar/whois-privacy/#get
+      #
+      # @example Get the whois privacy for "example.com":
+      #   client.registrar.get_whois_privacy(1010, "example.com")
+      #
+      # @param  [Fixnum] account_id the account ID
+      # @param  [#to_s] domain_name the domain name
+      # @param  [Hash] options
+      # @return [Struct::WhoisPrivacy]
+      #
+      # @raise  [RequestError] When the request fails.
+      def whois_privacy(account_id, domain_name, options = {})
+        endpoint = whois_privacy_endpoint(account_id, domain_name)
+        response = client.get(endpoint, options)
+
+        Dnsimple::Response.new(response, Struct::WhoisPrivacy.new(response["data"]))
+      end
+
+      # Enables whois privacy for the domain.
+      #
+      # @see https://developer.dnsimple.com/v2/registrar/whois-privacy/#enable
+      #
+      # @example Enable whois privacy for "example.com":
+      #   client.registrar.enable_whois_privacy(1010, "example.com")
+      #
+      # @param  [Fixnum] account_id the account ID
+      # @param  [#to_s] domain_name the domain name
+      # @param  [Hash] options
+      # @return [Struct::WhoisPrivacy]
+      #
+      # @raise  [RequestError] When the request fails.
+      def enable_whois_privacy(account_id, domain_name, options = {})
+        endpoint = whois_privacy_endpoint(account_id, domain_name)
+        response = client.put(endpoint, nil, options)
+
+        Dnsimple::Response.new(response, Struct::WhoisPrivacy.new(response["data"]))
+      end
+
+      # Disables whois privacy for the domain.
+      #
+      # @see https://developer.dnsimple.com/v2/registrar/whois-privacy/#disable
+      #
+      # @example Disable whois privacy for "example.com":
+      #   client.registrar.disable_whois_privacy(1010, "example.com")
+      #
+      # @param  [Fixnum] account_id the account ID
+      # @param  [#to_s] domain_name The domain name to check.
+      # @param  [Hash] options
+      # @return [Struct::WhoisPrivacy]
+      #
+      # @raise  [RequestError] When the request fails.
+      def disable_whois_privacy(account_id, domain_name, options = {})
+        endpoint = whois_privacy_endpoint(account_id, domain_name)
+        response = client.delete(endpoint, nil, options)
+
+        Dnsimple::Response.new(response, Struct::WhoisPrivacy.new(response["data"]))
+      end
+
+
+      private
+
+      def whois_privacy_endpoint(account_id, domain_name)
+        Client.versioned("/%s/registrar/domains/%s/whois_privacy" % [account_id, domain_name])
+      end
+
+    end
+  end
+end