dnsimple 2.0.0.a

data/lib/dnsimple/contact.rb

@@ -0,0 +1,154 @@
+module DNSimple
+
+  # Represents a contact.
+  class Contact < Base
+
+    Aliases = {
+      'first'             => 'first_name',
+      'last'              => 'last_name',
+      'state'             => 'state_province',
+      'province'          => 'state_province',
+      'state_or_province' => 'state_province',
+      'email'             => 'email_address',
+    }
+
+    # The contact ID in DNSimple
+    attr_accessor :id
+
+    # The contact first name
+    attr_accessor :first_name
+
+    # The contact last name
+    attr_accessor :last_name
+
+    # The contact's job title
+    attr_accessor :job_title
+
+    # The name of the organization in which the contact works
+    attr_accessor :organization_name
+
+    # The contact email address
+    attr_accessor :email_address
+
+    # The contact phone number
+    attr_accessor :phone
+
+    # The contact phone extension (may be omitted)
+    attr_accessor :phone_ext
+
+    # The contact fax number (may be omitted)
+    attr_accessor :fax
+
+    # The contact street address
+    attr_accessor :address1
+
+    # Apartment or suite number
+    attr_accessor :address2
+
+    # The city name
+    attr_accessor :city
+
+    # The state or province name
+    attr_accessor :state_province
+
+    # The contact postal code
+    attr_accessor :postal_code
+
+    # The contact country (as a 2-character country code)
+    attr_accessor :country
+
+    # When the contact was created in DNSimple
+    attr_accessor :created_at
+
+    # When the contact was last updated in DNSimple
+    attr_accessor :updated_at
+
+
+    # Map an aliased field name to it's real name. For example, if you
+    # pass "first" it will be resolved to "first_name", "email" is resolved
+    # to "email_address" and so on.
+    def self.resolve(name)
+      DNSimple::Contact::Aliases[name.to_s] || name
+    end
+
+    def self.resolve_attributes(attributes)
+      resolved_attributes = {}
+      attributes.each do |k, v|
+        resolved_attributes[resolve(k)] = v
+      end
+      resolved_attributes
+    end
+
+    # Create the contact with the given attributes in DNSimple.
+    # This method returns a Contact instance of the contact is created
+    # and raises an error otherwise.
+    def self.create(attributes, options={})
+      contact_hash = resolve_attributes(attributes)
+
+      options.merge!({:body => {:contact => contact_hash}})
+      response = DNSimple::Client.post("/v1/contacts", options)
+
+      case response.code
+      when 201
+        new(response["contact"])
+      else
+        raise RequestError.new("Error creating contact", response)
+      end
+    end
+
+    def self.find(id, options={})
+      response = DNSimple::Client.get("/v1/contacts/#{id}", options)
+
+      case response.code
+      when 200
+        new(response["contact"])
+      when 404
+        raise RecordNotFound, "Could not find contact #{id}"
+      else
+        raise RequestError.new("Error finding contact", response)
+      end
+    end
+
+    def self.all(options={})
+      response = DNSimple::Client.get("/v1/contacts", options)
+
+      case response.code
+      when 200
+        response.map { |r| new(r["contact"]) }
+      else
+        raise RequestError.new("Error listing contacts", response)
+      end
+    end
+
+
+    def name
+      [first_name, last_name].join(' ')
+    end
+
+    def save(options={})
+      contact_hash = {}
+      %w(first_name last_name organization_name job_title address1 address2 city
+      state_province postal_code country email_address phone phone_ext fax).each do |attribute|
+        contact_hash[DNSimple::Contact.resolve(attribute)] = self.send(attribute)
+      end
+
+      options.merge!({:body => {:contact => contact_hash}})
+
+      response = DNSimple::Client.put("/v1/contacts/#{id}", options)
+
+      case response.code
+        when 200
+          return self
+        else
+          raise RequestError.new("Error updating contact", response)
+      end
+    end
+
+    # Delete the contact from DNSimple. WARNING: this cannot be undone.
+    def delete(options={})
+      DNSimple::Client.delete("/v1/contacts/#{id}", options)
+    end
+    alias :destroy :delete
+
+  end
+end

data/lib/dnsimple/domain.rb

@@ -0,0 +1,217 @@
+module DNSimple
+  class Domain < Base
+
+    # The domain ID in DNSimple
+    attr_accessor :id
+
+    # The domain name
+    attr_accessor :name
+
+    # When the domain was created in DNSimple
+    attr_accessor :created_at
+
+    # When the domain was last update in DNSimple
+    attr_accessor :updated_at
+
+    # The current known name server status
+    attr_accessor :name_server_status
+
+    # When the domain is due to expire
+    attr_accessor :expires_on
+
+    # The state of the domain in DNSimple
+    attr_accessor :state
+
+    # ID of the registrant in DNSimple
+    attr_accessor :registrant_id
+
+    # User ID in DNSimple
+    attr_accessor :user_id
+    
+    # Is the domain lockable
+    attr_accessor :lockable
+    
+    # Is the domain set to autorenew
+    attr_accessor :auto_renew
+    
+    # Is the whois information protected
+    attr_accessor :whois_protected
+
+
+    # Check the availability of a name
+    def self.check(name, options={})
+      response = DNSimple::Client.get("/v1/domains/#{name}/check", options)
+
+      case response.code
+      when 200
+        "registered"
+      when 404
+        "available"
+      else
+        raise RequestError.new("Error checking availability", response)
+      end
+    end
+
+    # Create the domain with the given name in DNSimple. This
+    # method returns a Domain instance if the name is created
+    # and raises an error otherwise.
+    def self.create(name, options={})
+      options.merge!({:body => {:domain => {:name => name}}})
+
+      response = DNSimple::Client.post("/v1/domains", options)
+
+      case response.code
+      when 201
+        new(response["domain"])
+      else
+        raise RequestError.new("Error creating domain", response)
+      end
+    end
+
+    # Purchase a domain name.
+    def self.register(name, registrant={}, extended_attributes={}, options={})
+      body = {:domain => {:name => name}}
+      if registrant
+        if registrant[:id]
+          body[:domain][:registrant_id] = registrant[:id]
+        else
+          body.merge!(:contact => DNSimple::Contact.resolve_attributes(registrant))
+        end
+      end
+      body.merge!(:extended_attribute => extended_attributes)
+      options.merge!({:body => body})
+
+      response = DNSimple::Client.post("/v1/domain_registrations", options)
+
+      case response.code
+      when 201
+        return DNSimple::Domain.new(response["domain"])
+      else
+        raise RequestError.new("Error registering domain", response)
+      end
+    end
+
+    # Find a specific domain in the account either by the numeric ID
+    # or by the fully-qualified domain name.
+    def self.find(id, options={})
+      response = DNSimple::Client.get("/v1/domains/#{id}", options)
+
+      case response.code
+      when 200
+        new(response["domain"])
+      when 404
+        raise RecordNotFound, "Could not find domain #{id}"
+      else
+        raise RequestError.new("Error finding domain", response)
+      end
+    end
+
+    # Get all domains for the account.
+    def self.all(options={})
+      response = DNSimple::Client.get("/v1/domains", options)
+
+      case response.code
+      when 200
+        response.map { |r| new(r["domain"]) }
+      else
+        raise RequestError.new("Error listing domains", response)
+      end
+    end
+
+    # Enable auto_renew on the domain
+    def enable_auto_renew
+      return if auto_renew
+      auto_renew!(:post)
+    end
+
+    # Disable auto_renew on the domain
+    def disable_auto_renew
+      return unless auto_renew
+      auto_renew!(:delete)
+    end
+
+    # Delete the domain from DNSimple. WARNING: this cannot
+    # be undone.
+    def delete(options={})
+      DNSimple::Client.delete("/v1/domains/#{name}", options)
+    end
+    alias :destroy :delete
+
+    # Apply the given named template to the domain. This will add
+    # all of the records in the template to the domain.
+    def apply(template, options={})
+      options.merge!(:body => {})
+      template = resolve_template(template)
+
+      DNSimple::Client.post("/v1/domains/#{name}/templates/#{template.id}/apply", options)
+    end
+
+    def resolve_template(template)
+      case template
+      when DNSimple::Template
+        template
+      else
+        DNSimple::Template.find(template)
+      end
+    end
+
+    def applied_services(options={})
+      response = DNSimple::Client.get("/v1/domains/#{name}/applied_services", options)
+
+      case response.code
+      when 200
+        response.map { |r| DNSimple::Service.new(r["service"]) }
+      else
+        raise RequestError.new("Error listing applied services", response)
+      end
+    end
+
+    def available_services(options={})
+      response = DNSimple::Client.get("/v1/domains/#{name}/available_services", options)
+
+      case response.code
+      when 200
+        response.map { |r| DNSimple::Service.new(r["service"]) }
+      else
+        raise RequestError.new("Error listing available services", response)
+      end
+    end
+
+    def add_service(id_or_short_name, options={})
+      options.merge!(:body => {:service => {:id => id_or_short_name}})
+      response = DNSimple::Client.post("/v1/domains/#{name}/applied_services", options)
+
+      case response.code
+      when 200
+        true
+      else
+        raise RequestError.new("Error adding service", response)
+      end
+    end
+
+    def remove_service(id, options={})
+      response = DNSimple::Client.delete("/v1/domains/#{name}/applied_services/#{id}", options)
+
+      case response.code
+      when 200
+        true
+      else
+        raise RequestError.new("Error removing service", response)
+      end
+    end
+
+
+    private
+
+    def auto_renew!(method)
+      response = DNSimple::Client.send(method, "/v1/domains/#{name}/auto_renewal")
+      case response.code
+      when 200
+        self.auto_renew = response['domain']['auto_renew']
+      else
+        raise RequestError.new("Error setting auto_renew", response)
+      end
+    end
+
+  end
+end

data/lib/dnsimple/error.rb

@@ -0,0 +1,21 @@
+module DNSimple
+
+  class Error < StandardError
+  end
+
+  class RecordExists < Error
+  end
+
+  class RecordNotFound < Error
+  end
+
+  class RequestError < Error
+    def initialize(description, response)
+      super("#{description}: #{response["error"]}")
+    end
+  end
+
+  class AuthenticationFailed < Error
+  end
+
+end

data/lib/dnsimple/extended_attribute.rb

@@ -0,0 +1,52 @@
+module DNSimple
+
+  # Used for domains that require extended attributes.
+  class ExtendedAttribute < Base
+
+    # An option for an extended attribute
+    class Option < Base
+      # The option name
+      attr_accessor :title
+
+      # The option value
+      attr_accessor :value
+
+      # A long description of the option
+      attr_accessor :description
+    end
+
+    # The extended attribute name
+    attr_accessor :name
+
+    # A description of the extended attribute
+    attr_accessor :description
+
+    # Boolean indicating if the extended attribute is required
+    attr_accessor :required
+
+    # An array of options for the extended attribute
+    def options
+      @options ||= []
+    end
+
+    def options=(opts)
+      @options = []
+      opts.each do |opt|
+        @options << DNSimple::ExtendedAttribute::Option.new(opt)
+      end
+    end
+
+    # Find the extended attributes for the given TLD
+    def self.find(tld, options={})
+      response = DNSimple::Client.get("/v1/extended_attributes/#{tld}", options)
+
+      case response.code
+      when 200
+        response.map { |r| new(r) }
+      else
+        raise RequestError.new("Error finding extended attributes", response)
+      end
+    end
+
+  end
+end

data/lib/dnsimple/record.rb

@@ -0,0 +1,94 @@
+module DNSimple
+
+  class Record < Base
+    Aliases = {
+      'priority'     => 'prio',
+      'time-to-live' => 'ttl'
+    }
+
+    attr_accessor :id
+    attr_accessor :domain
+    attr_accessor :name
+    attr_accessor :content
+    attr_accessor :ttl
+    attr_accessor :prio
+    attr_accessor :record_type
+
+
+    def fqdn
+      [name, domain.name].delete_if { |v| v !~ DNSimple::BLANK_REGEX }.join(".")
+    end
+
+    def save(options={})
+      record_hash = {}
+      %w(name content ttl prio).each do |attribute|
+        record_hash[DNSimple::Record.resolve(attribute)] = self.send(attribute)
+      end
+
+      options.merge!(:body => {:record => record_hash})
+
+      response = DNSimple::Client.put("/v1/domains/#{domain.id}/records/#{id}", options)
+
+      case response.code
+      when 200
+        self
+      else
+        raise RequestError.new("Error updating record", response)
+      end
+    end
+
+    def delete(options={})
+      DNSimple::Client.delete("/v1/domains/#{domain.id}/records/#{id}", options)
+    end
+    alias :destroy :delete
+
+    def self.resolve(name)
+      DNSimple::Record::Aliases[name] || name
+    end
+
+    def self.create(domain, name, record_type, content, options={})
+      record_hash = {:name => name, :record_type => record_type, :content => content}
+      record_hash[:ttl] = options.delete(:ttl) || 3600
+      record_hash[:prio] = options.delete(:priority)
+      record_hash[:prio] = options.delete(:prio) || ''
+
+      options.merge!({:body => {:record => record_hash}})
+
+      response = DNSimple::Client.post("/v1/domains/#{domain.name}/records", options)
+
+      case response.code
+      when 201
+        new({:domain => domain}.merge(response["record"]))
+      when 406
+        raise RecordExists, "Record #{name}.#{domain.name} already exists"
+      else
+        raise RequestError.new("Error creating record", response)
+      end
+    end
+
+    def self.find(domain, id, options={})
+      response = DNSimple::Client.get("/v1/domains/#{domain.name}/records/#{id}", options)
+
+      case response.code
+      when 200
+        new({:domain => domain}.merge(response["record"]))
+      when 404
+        raise RecordNotFound, "Could not find record #{id} for domain #{domain.name}"
+      else
+        raise RequestError.new("Error finding record", response)
+      end
+    end
+
+    def self.all(domain, options={})
+      response = DNSimple::Client.get("/v1/domains/#{domain.name}/records", options)
+
+      case response.code
+      when 200
+        response.map { |r| new({:domain => domain}.merge(r["record"])) }
+      else
+        raise RequestError.new("Error listing records", response)
+      end
+    end
+
+  end
+end