sparqcode-dnsimple-ruby 1.2.6

data/lib/dnsimple/commands/list_templates.rb

@@ -0,0 +1,13 @@
+module DNSimple
+  module Commands
+    class ListTemplates
+      def execute(args, options={})
+        templates = Template.all
+        puts "Found #{templates.length} templates:"
+        templates.each do |template|
+          puts "\t#{template.name} (short_name:#{template.short_name})" 
+        end
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/purchase_certificate.rb

@@ -0,0 +1,19 @@
+require 'dnsimple/command'
+
+module DNSimple
+  module Commands
+    class PurchaseCertificate < Command
+      def execute(args, options={})
+        domain_name = args.shift
+        name = args.shift
+        contact_id = args.shift
+
+        domain = Domain.find(domain_name)
+        contact = Contact.find(contact_id)
+        
+        certificate = Certificate.purchase(domain, name, contact)
+        say "Purchased certificate for #{certificate.fqdn}"
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/register_domain.rb

@@ -0,0 +1,33 @@
+module DNSimple
+  module Commands
+    class RegisterDomain
+      def execute(args, options={})
+        name = args.shift
+        registrant = nil
+
+        registrant_id_or_attribute = args.shift
+        if registrant_id_or_attribute
+          if registrant_id_or_attribute =~ /^\d+$/
+            registrant = {:id => registrant_id_or_attribute}
+          else
+            args.unshift(registrant_id_or_attribute)
+          end
+        end
+
+        extended_attributes = {}
+        args.each do |arg|
+          n, v = arg.split(":")
+          extended_attributes[n] = v
+        end
+
+        domain = Domain.register(name, registrant, extended_attributes)
+        puts "Registered #{domain.name}"
+
+        if template = options.delete(:template)
+          domain.apply(template)
+          puts "Applied template #{template} to #{domain.name}"
+        end
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/remove_service.rb

@@ -0,0 +1,14 @@
+module DNSimple
+  module Commands
+    class RemoveService
+      def execute(args, options={})
+        domain_name = args.shift
+        domain = Domain.find(domain_name)
+        short_name = args.shift
+        service = Service.find(short_name)
+        domain.remove_service(service.id)
+        puts "Removed #{service.name} from #{domain_name}"
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/submit_certificate.rb

@@ -0,0 +1,19 @@
+require 'dnsimple/command'
+
+module DNSimple
+  module Commands
+    class SubmitCertificate < Command
+      def execute(args, options={})
+        domain_name = args.shift
+        certificate_id = args.shift
+        approver_email = args.shift
+        
+        domain = DNSimple::Domain.find(domain_name)
+        certificate = DNSimple::Certificate.find(domain, certificate_id)
+        certificate.submit(approver_email)
+
+        say "Certificate submitted, authorization by email required"
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/transfer_domain.rb

@@ -0,0 +1,21 @@
+module DNSimple
+  module Commands
+    class TransferDomain
+      def execute(args, options={})
+        name = args.shift
+        registrant = {:id => args.shift}
+        authinfo = args.shift unless args.empty?
+        authinfo ||= ''
+
+        extended_attributes = {}
+        args.each do |arg|
+          n, v = arg.split(":")
+          extended_attributes[n] = v
+        end
+
+        transfer_order = TransferOrder.create(name, authinfo, registrant, extended_attributes)
+        puts "Transfer order issued for #{name}"
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/update_contact.rb

@@ -0,0 +1,25 @@
+module DNSimple
+  module Commands
+    class UpdateContact
+      # Execute the contact:update command.
+      #
+      # Args expected:
+      # id [name:value name:value ...]
+      def execute(args, options={})
+        attributes = {}
+        id = args.shift
+        args.each do |arg|
+          name, value = arg.split(":")
+          attributes[Contact.resolve(name)] = value
+        end 
+
+        contact = Contact.find(id)
+        attributes.each do |name, value|
+          contact.send("#{name}=", value)
+        end
+        contact.save
+        puts "Updated contact #{contact.name} (id: #{contact.id})"
+      end
+    end
+  end
+end

data/lib/dnsimple/commands/update_record.rb

@@ -0,0 +1,23 @@
+module DNSimple
+  module Commands
+    class UpdateRecord
+      def execute(args, options={})
+        attributes = {}
+        domain_name = args.shift
+        id = args.shift
+        args.each do |arg|
+          name, value = arg.split(":")
+          attributes[Record.resolve(name)] = value
+        end
+
+        domain = Domain.find(domain_name)
+        record = Record.find(domain, id)
+        attributes.each do |name, value|
+          record.send("#{name}=", value)
+        end
+        record.save
+        puts "Updated record #{record.fqdn} (id: #{record.id})"
+      end
+    end
+  end
+end

data/lib/dnsimple/contact.rb

@@ -0,0 +1,181 @@
+module DNSimple #:nodoc:
+  # CLass representing a contact in DNSimple
+  class Contact
+    include HTTParty
+
+    # The contact ID in DNSimple
+    attr_accessor :id
+
+    # The name of the organization in which the contact works
+    # (may be omitted)
+    attr_accessor :organization_name
+
+    # The contact first name
+    attr_accessor :first_name
+
+    # The contact last name
+    attr_accessor :last_name
+
+    # The contact's job title (may be omitted)
+    attr_accessor :job_title
+
+    # 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
+
+    # 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
+
+    # When the contact was created in DNSimple
+    attr_accessor :created_at
+
+    # When the contact was last updated in DNSimple
+    attr_accessor :updated_at
+
+    #:nodoc:
+    def initialize(attributes)
+      attributes.each do |key, value|
+        m = "#{key}=".to_sym
+        self.send(m, value) if self.respond_to?(m)
+      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[Contact.resolve(attribute)] = self.send(attribute)
+      end
+
+      options.merge!(DNSimple::Client.standard_options_with_credentials)
+      options.merge!({:body => {:contact => contact_hash}})
+      
+      response = self.class.put("#{Client.base_uri}/contacts/#{id}", options)
+
+      pp response if Client.debug?
+
+      case response.code
+      when 200
+        return self
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise RuntimeError, "Failed to update contact: #{response.inspect}"
+      end
+    end
+
+    # Delete the contact from DNSimple. WARNING: this cannot be undone.
+    def delete(options={})
+      options.merge!({:basic_auth => Client.credentials})
+      self.class.delete("#{Client.base_uri}/contacts/#{id}.json", options)
+    end
+    alias :destroy :delete
+
+    # 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)
+      aliases = {
+        'first' => 'first_name',
+        'last' => 'last_name',
+        'state' => 'state_province',
+        'province' => 'state_province',
+        'state_or_province' => 'state_province',
+        'email' => 'email_address',
+      }
+      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}})
+      options.merge!({:basic_auth => Client.credentials})
+
+      response = self.post("#{Client.base_uri}/contacts.json", options)
+
+      pp response if Client.debug?
+
+      case response.code
+      when 201
+        return Contact.new(response["contact"])
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise RuntimeError, "Failed to create contact: #{response.inspect}"
+      end
+    end
+
+    def self.find(id, options={})
+      options.merge!({:basic_auth => Client.credentials})
+      response = self.get("#{Client.base_uri}/contacts/#{id}.json", options)
+
+      pp response if Client.debug?
+
+      case response.code
+      when 200
+        return Contact.new(response["contact"])
+      when 401
+        raise RuntimeError, "Authentication failed"
+      when 404
+        raise RuntimeError, "Could not find contact #{id}"
+      else
+        raise DNSimple::Error.new(id, response["errors"])
+      end
+    end
+
+    def self.all(options={})
+      options.merge!({:basic_auth => Client.credentials})
+      response = self.get("#{Client.base_uri}/contacts.json", options)
+
+      pp response if Client.debug?
+
+      case response.code
+      when 200
+        response.map { |r| Contact.new(r["contact"]) }
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise RuntimeError, "Error: #{response.code}"
+      end
+    end
+  end
+end

data/lib/dnsimple/domain.rb

@@ -0,0 +1,246 @@
+module DNSimple #:nodoc:
+  # Class representing a single domain in DNSimple.
+  class Domain
+    include HTTParty
+
+    # 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
+
+    #:nodoc:
+    def initialize(attributes)
+      attributes.each do |key, value|
+        m = "#{key}=".to_sym
+        self.send(m, value) if self.respond_to?(m)
+      end
+    end
+
+    # Delete the domain from DNSimple. WARNING: this cannot
+    # be undone.
+    def delete(options={})
+      options.merge!(DNSimple::Client.standard_options_with_credentials)
+      self.class.delete("#{DNSimple::Client.base_uri}/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!(DNSimple::Client.standard_options_with_credentials)
+      options.merge!(:body => {})
+      template = resolve_template(template)
+      self.class.post("#{DNSimple::Client.base_uri}/domains/#{name}/templates/#{template.id}/apply", options)
+    end
+    
+    # Overwrite the nameservers for a given domain.
+    def update_name_servers(name_servers, options = {})
+      options.merge!(DNSimple::Client.standard_options_with_credentials)
+      
+      name_servers_hash = {}
+      ns_index = 1
+      
+      name_servers.each do |name_server|
+        name_servers_hash["ns#{ns_index}"] = name_server
+        ns_index += 1
+      end
+      
+      options.merge!(:body => { :name_servers => name_servers_hash })
+      
+      response = self.class.post("#{DNSimple::Client.base_uri}/domains/#{name}/name_servers.json", options)
+      pp response if DNSimple::Client.debug?
+      
+      case response.code
+        
+      when 200
+        name_servers
+      else
+        raise RuntimeError, "Error: #{response.code}"
+      end
+    end
+
+    #:nodoc:
+    def resolve_template(template)
+      case template
+      when DNSimple::Template
+        template
+      else
+        DNSimple::Template.find(template)
+      end
+    end
+
+    def applied_services(options={})
+      options.merge!(DNSimple::Client.standard_options_with_credentials)
+      response = self.class.get("#{Client.base_uri}/domains/#{name}/applied_services", options)
+      pp response if DNSimple::Client.debug?
+      case response.code
+      when 200
+        response.map { |r| DNSimple::Service.new(r["service"]) }
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise RuntimeError, "Error: #{response.code}"
+      end
+    end
+
+    def available_services(options={})
+      options.merge!(DNSimple::Client.standard_options_with_credentials)
+      response = self.class.get("#{DNSimple::Client.base_uri}/domains/#{name}/available_services", options)
+      pp response if DNSimple::Client.debug?
+      case response.code
+      when 200
+        response.map { |r| DNSimple::Service.new(r["service"]) }
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise RuntimeError, "Error: #{response.code}"
+      end
+    end
+
+    def add_service(id_or_short_name, options={})
+      options.merge!(DNSimple::Client.standard_options_with_credentials)
+      options.merge!(:body => {:service => {:id => id_or_short_name}})
+      response = self.class.post("#{DNSimple::Client.base_uri}/domains/#{name}/applied_services", options)
+      pp response if DNSimple::Client.debug?
+      case response.code
+      when 200
+        true
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise "Error: #{response.code}"
+      end
+    end
+
+    def remove_service(id, options={})
+      options.merge!(DNSimple::Client.standard_options_with_credentials)
+      response = self.class.delete("#{DNSimple::Client.base_uri}/domains/#{name}/applied_services/#{id}", options)
+      pp response if DNSimple::Client.debug?
+      case response.code
+      when 200
+        true
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise "Error: #{response.code}"
+      end
+    end
+
+    # Check the availability of a name
+    def self.check(name, options={})
+      options.merge!(DNSimple::Client.standard_options_with_credentials)
+      response = self.get("#{DNSimple::Client.base_uri}/domains/#{name}/check", options)
+      pp response if DNSimple::Client.debug?
+      case response.code
+      when 200
+        "registered"
+      when 401
+        raise RuntimeError, "Authentication failed"
+      when 404
+        "available"
+      else
+        raise "Error: #{response.code}" 
+      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!(DNSimple::Client.standard_options_with_credentials)
+
+      domain_hash = {:name => name}
+      options.merge!({:body => {:domain => domain_hash}})
+
+      response = self.post("#{DNSimple::Client.base_uri}/domains", options)
+      
+      pp response if DNSimple::Client.debug?
+      
+      case response.code
+      when 201
+        return DNSimple::Domain.new(response["domain"])
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise DNSimple::DomainError.new(name, response["errors"])
+      end
+    end
+
+    # Purchase a domain name.
+    def self.register(name, registrant={}, extended_attributes={}, options={})
+      options.merge!(DNSimple::Client.standard_options_with_credentials)
+
+      body = {:domain => {:name => name}}
+      if registrant
+        if registrant[:id]
+          body[:domain][:registrant_id] = registrant[:id]
+        else
+          body.merge!(:contact => Contact.resolve_attributes(registrant))
+        end
+      end
+      body.merge!(:extended_attribute => extended_attributes)
+      options.merge!({:body => body})
+      
+      response = self.post("#{DNSimple::Client.base_uri}/domain_registrations", options)
+      
+      pp response if DNSimple::Client.debug?
+      
+      case response.code
+      when 201
+        return DNSimple::Domain.new(response["domain"])
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise DNSimple::DomainError.new(name, response["errors"])
+      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_or_name, options={})
+      options.merge!(DNSimple::Client.standard_options_with_credentials)
+      response = self.get("#{DNSimple::Client.base_uri}/domains/#{id_or_name}", options)
+      
+      pp response if DNSimple::Client.debug?
+      
+      case response.code
+      when 200
+        return DNSimple::Domain.new(response["domain"])
+      when 401
+        raise RuntimeError, "Authentication failed"
+      when 404
+        raise RuntimeError, "Could not find domain #{id_or_name}"
+      else
+        raise DNSimple::DomainError.new(id_or_name, response["errors"])
+      end
+    end
+
+    # Get all domains for the account.
+    def self.all(options={})
+      options.merge!(DNSimple::Client.standard_options_with_credentials)
+      response = self.get("#{DNSimple::Client.base_uri}/domains", options)
+      
+      pp response if DNSimple::Client.debug?
+
+      case response.code
+      when 200
+        response.map { |r| DNSimple::Domain.new(r["domain"]) }
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise RuntimeError, "Error: #{response.code}"
+      end
+    end
+
+  end
+end