internetbs 1.0.0

data/lib/internetbs/domain_contact.rb

@@ -0,0 +1,109 @@
+require_relative 'country_codes'
+
+module InternetBS
+  class DomainContact < Base
+    attribute :additional_attributes, AdditionalAttributes
+    attribute :city,                  String
+    attribute :contact_type,          String  # Internal - symbol: one of :registrant, :admin, :billing, :tech, :zone
+    attribute :country,               String  # Read only - returned by DomainInformation
+    attribute :country_code,          String  # Must be one in COUNTRY_CODES
+    attribute :email,                 String
+    attribute :fax,                   String  # Optional - only supported for .uk
+    attribute :first_name,            String
+    attribute :last_name,             String
+    attribute :obfuscate_email,       Boolean, :default => false # Optional - only supported for .com/.net/.tv, 1 = obfuscate, 0 = not
+    attribute :organization,          String  # Required for .uk, otherwise optional, only effective when private whois is disabled
+    attribute :phone_number,          String
+    attribute :postal_code,           String
+    attribute :street,                String
+    attribute :street_2,              String  # Optional
+    attribute :street_3,              String  # Optional
+    
+    def initialize(attributes = nil)
+      super(attributes)
+      
+      # Add any additional attributes
+      case @domain_extension
+      when 'asia'
+        @additional_attributes = DotAsiaAttributes.new
+      when 'de'
+        @additional_attributes = DotDEAttributes.new
+      when 'eu'
+        @additional_attributes = DotEUAttributes.new
+      when 'fr', 're', 'pm', 'tf', 'wf', 'yt'
+        @additional_attributes = DotFRAttributes.new
+      when 'it'
+        @additional_attributes = DotITAttributes.new
+      when 'nl'
+        @additional_attributes = DotDLAttributes.new
+      when 'uk'
+        @additional_attributes = DotUKAttributes.new
+      when 'us'
+        @additional_attributes = DotUSAttributes.new
+      end
+      
+      # Set contact_type and domain_extension for additional attributes
+      @additional_attributes.contact_type = @contact_type
+      @additional_attributes.domain_extension = @domain_extension
+    end
+    
+    def params
+      contact = {
+        "#{@contact_type.to_s}_firstname"    => @first_name,
+        "#{@contact_type.to_s}_lastname"     => @last_name,
+        "#{@contact_type.to_s}_email"        => @email,
+        "#{@contact_type.to_s}_phone_number" => @phone_number,
+        "#{@contact_type.to_s}_city"         => @city,
+        "#{@contact_type.to_s}_street"       => @street,
+        "#{@contact_type.to_s}_postal_code"  => @postal_code,
+        "#{@contact_type.to_s}_country_code" => @country_code
+      }
+      
+      if @organization || @domain_extension == 'uk'
+        contact.merge!({"#{@contact_type.to_s}_organization" => @organization})
+      end
+      
+      if @fax && @domain_extension == 'uk'
+        contact.merge!({"#{@contact_type.to_s}_fax" => @fax})
+      end
+      
+      if %w[com net tv].include?(@domain_extension)
+        contact.merge!({"#{@contact_type.to_s}_obfuscateemail" => @obfuscate_email ? 1 : 0})
+      end
+      
+      if @street_2
+        contact.merge!({"#{@contact_type.to_s}_street2" => @street_2})
+      end
+
+      if @street_3
+        contact.merge!({"#{@contact_type.to_s}_street3" => @street_3})
+      end
+      
+      case @contact_type
+      when :registrant
+        contact.merge!(@additional_attributes.registrant_params)
+      when :admin
+        contact.merge!(@additional_attributes.admin_params)
+      when :billing
+        contact.merge!(@additional_attributes.billing_params)
+      when :tech
+        contact.merge!(@additional_attributes.tech_params)
+      when :zone # .de only
+        contact.merge!(@additional_attributes.zone_params) if @domain_extension == 'de'
+      end
+
+      contact.merge!(@additional_attributes.mandatory_params)
+      contact.merge!(@additional_attributes.optional_params)
+      
+      return contact
+    end
+    
+    def valid?
+      ensure_attribute_has_value :first_name, :last_name, :email,
+       :phone_number, :city, :street, :postal_code, :country_code
+      unless COUNTRY_CODES.has_key?(@country_code)
+        @errors << "country_code must be one in COUNTRY_CODES"
+      end
+    end
+  end
+end

data/lib/internetbs/domain_host.rb

@@ -0,0 +1,46 @@
+module InternetBS
+  class DomainHost < Base
+    attribute :host,         String
+    attribute :ip_addresses, Array[String]
+  
+    def fetch
+      ensure_attribute_has_value :host
+      return false if @errors.any?
+      
+      params = {'host' => @host}
+      response = Client.get('/domain/host/info', params)
+      
+      case response.code
+      when '200'
+        hash = JSON.parse(response.body)
+
+        @status = hash['status']
+        @transaction_id = hash['transactid']
+        
+        unless @status == 'SUCCESS'
+          set_errors(response)
+          return false
+        end
+        
+        return true
+      else
+        set_errors(response)
+        return false
+      end
+    end
+  
+    def valid?
+      ensure_attribute_has_value :host
+      
+      unless ip_addresses.any?
+        @errors << 'at least one ip address is required'
+      end
+
+      if @errors.any?
+        return false
+      else
+        return true
+      end
+    end
+  end
+end

data/lib/internetbs/domain_hosts.rb

@@ -0,0 +1,101 @@
+module InternetBS
+  class DomainHosts < Base
+    attribute :compact, Boolean, :default => true
+    attribute :domain,  String
+    attribute :list,    Array[DomainHost]
+    
+    def add(domain_host)
+      set_record :create, domain_host
+    end
+    
+    def fetch
+      ensure_attribute_has_value :domain
+      return false if @errors.any?
+      
+      params = {'domain' => @domain}
+      params.merge!({'compactlist' => @compact ? 'YES' : 'NO'}) if @compact
+        
+      response = Client.get('/domain/host/list', params)
+      code = response.code rescue ""
+      
+      case code
+      when '200'
+        hash = JSON.parse(response.body)
+
+        @status = hash['status']
+        @transaction_id = hash['transactid']
+        
+        if @status == 'SUCCESS'
+          total_hosts = hash['total_hosts'].to_i
+          if total_hosts > 0
+            hash['host'].each do |key, value|
+              @list << DomainHost.new(:host => value)
+            end
+          end
+        else
+          set_errors(response)
+          return false
+        end
+        
+        return true
+      else
+        set_errors(response)
+        return false
+      end
+    end
+    
+    def remove(domain_host)
+      set_record :delete, domain_host
+    end
+    
+    def update(domain_host)
+      set_record :update, domain_host
+    end
+    
+    private
+    
+    # Expects an action parameter of either :create, :update or :delete.
+    def set_record(action, domain_host)
+      @errors.clear
+      
+      case action
+      when :create, :update
+        unless domain_host.valid?
+          @errors = domain_host.errors
+          return false
+        end
+      when :delete
+        unless domain_host.host
+          @errors = 'host is required'
+          return false
+        end
+      end
+      
+      params = {'host' => domain.host}
+      
+      if [:create, :update].include?(action)
+        params.merge!({:ip_list => @ip_addresses.join(',')})
+      end
+      
+      response = Client.post("/domain/host/#{action.to_s}", params)
+      
+      case response.code
+      when '200'
+        hash = JSON.parse(response.body)
+
+        @status = hash['status']
+        @transaction_id = hash['transactid']
+        
+        unless @status == 'SUCCESS'
+          set_errors(response)
+          return false
+        end
+        
+        return true
+      else
+        set_errors(response)
+        return false
+      end
+    end
+  end
+end

data/lib/internetbs/domain_information.rb

@@ -0,0 +1,128 @@
+module InternetBS
+  class DomainInformation < Base
+    attribute :auto_renew,         Boolean
+    attribute :contacts,           Array[DomainContact]
+    attribute :domain,             String
+    attribute :domain_extension,   String
+    attribute :domain_status,      String # REGISTERED, REGISTRAR LOCKED, PENDING TRANSFER, PENDING TRADE, ON HOLD, EXPIRED, UNKNOWN
+    attribute :expiration_date,    Date
+    attribute :private_whois,      String # DISABLED or FULL or PARTIAL
+    attribute :registrar_lock,     String # ENABLED or DISABLED or NOTADMITTED
+    attribute :transfer_auth_info, String
+      
+    def fetch
+      ensure_attribute_has_value :domain
+      return false if @errors.any?
+      
+      params = {'domain' => @domain}
+      response = Client.get('/domain/info', params)
+      code = response.code rescue ""
+      
+      case code
+      when '200'
+        hash = JSON.parse(response.body)        
+
+        @status = hash['status']
+        @transaction_id = hash['transactid']
+
+        if @status == 'SUCCESS'
+          @auto_renew         = hash['autorenew'] == 'YES' ? true : false
+          @domain_extension   = @domain.split('.').last
+          @domain_status      = hash['domainstatus']
+          @expiration_date    = hash['expirationdate']
+          @private_whois      = hash['privatewhois']
+          @registrar_lock     = hash['registrarlock']
+          @transfer_auth_info = hash['transferauthinfo']
+        
+          @contacts << DomainContact.new(
+            :contact_type => 'registrant',
+            :first_name   => hash['contacts']['registrant']['firstname'],
+            :last_name    => hash['contacts']['registrant']['lastname'],
+            :email        => hash['contacts']['registrant']['email'],
+            :phone_number => hash['contacts']['registrant']['phonenumber'],
+            :organization => hash['contacts']['registrant']['organization'],
+            :city         => hash['contacts']['registrant']['city'],
+            :street       => hash['contacts']['registrant']['street'],
+            :street_2     => hash['contacts']['registrant']['street2'],
+            :street_3     => hash['contacts']['registrant']['street3'],
+            :postal_code  => hash['contacts']['registrant']['postalcode'],
+            :country_code => hash['contacts']['registrant']['countrycode'],
+            :country      => hash['contacts']['registrant']['country']
+          )
+
+          @contacts << DomainContact.new(
+            :contact_type => 'tech',
+            :first_name   => hash['contacts']['technical']['firstname'],
+            :last_name    => hash['contacts']['technical']['lastname'],
+            :email        => hash['contacts']['technical']['email'],
+            :phone_number => hash['contacts']['technical']['phonenumber'],
+            :organization => hash['contacts']['technical']['organization'],
+            :city         => hash['contacts']['technical']['city'],
+            :street       => hash['contacts']['technical']['street'],
+            :street_2     => hash['contacts']['technical']['street2'],
+            :street_3     => hash['contacts']['technical']['street3'],
+            :postal_code  => hash['contacts']['technical']['postalcode'],
+            :country_code => hash['contacts']['technical']['countrycode'],
+            :country      => hash['contacts']['technical']['country']
+          )
+
+          @contacts << DomainContact.new(
+            :contact_type => 'admin',
+            :first_name   => hash['contacts']['admin']['firstname'],
+            :last_name    => hash['contacts']['admin']['lastname'],
+            :email        => hash['contacts']['admin']['email'],
+            :phone_number => hash['contacts']['admin']['phonenumber'],
+            :organization => hash['contacts']['admin']['organization'],
+            :city         => hash['contacts']['admin']['city'],
+            :street       => hash['contacts']['admin']['street'],
+            :street_2     => hash['contacts']['admin']['street2'],
+            :street_3     => hash['contacts']['admin']['street3'],
+            :postal_code  => hash['contacts']['admin']['postalcode'],
+            :country_code => hash['contacts']['admin']['countrycode'],
+            :country      => hash['contacts']['admin']['country']
+          )
+
+          if @domain_extension == 'de'
+            @contacts << DomainContact.new(
+              :contact_type => 'zone',
+              :first_name   => hash['contacts']['billing']['firstname'],
+              :last_name    => hash['contacts']['billing']['lastname'],
+              :email        => hash['contacts']['billing']['email'],
+              :phone_number => hash['contacts']['billing']['phonenumber'],
+              :organization => hash['contacts']['billing']['organization'],
+              :city         => hash['contacts']['billing']['city'],
+              :street       => hash['contacts']['billing']['street'],
+              :street_2     => hash['contacts']['billing']['street2'],
+              :street_3     => hash['contacts']['billing']['street3'],
+              :postal_code  => hash['contacts']['billing']['postalcode'],
+              :country_code => hash['contacts']['billing']['countrycode'],
+              :country      => hash['contacts']['billing']['country']
+          else
+            @contacts << DomainContact.new(
+              :contact_type => 'billing',
+              :first_name   => hash['contacts']['billing']['firstname'],
+              :last_name    => hash['contacts']['billing']['lastname'],
+              :email        => hash['contacts']['billing']['email'],
+              :phone_number => hash['contacts']['billing']['phonenumber'],
+              :organization => hash['contacts']['billing']['organization'],
+              :city         => hash['contacts']['billing']['city'],
+              :street       => hash['contacts']['billing']['street'],
+              :street_2     => hash['contacts']['billing']['street2'],
+              :street_3     => hash['contacts']['billing']['street3'],
+              :postal_code  => hash['contacts']['billing']['postalcode'],
+              :country_code => hash['contacts']['billing']['countrycode'],
+              :country      => hash['contacts']['billing']['country']
+          end
+        else
+          set_errors(response)
+          return false          
+        end
+        
+        return true
+      else
+        set_errors(response)
+        return false
+      end
+    end
+  end
+end

data/lib/internetbs/domain_push.rb

@@ -0,0 +1,33 @@
+module InternetBS
+  class DomainPush < Base
+    attribute :domain,        String # The domain being pushed
+    attribute :email_address, String # The destination account's email address
+  
+    def push!
+      ensure_attribute_has_value :domain, :email_address
+      return false if @errors.any?
+      
+      params = {'domain' => @domain, 'destination' => @email_address}
+      response = Client.post('/domain/push', params)
+      code = response.code rescue ""
+      
+      case code
+      when '200'
+        hash = JSON.parse(response.body)
+
+        @status = hash['status']
+        @transaction_id = hash['transactid']
+        
+        unless @status == 'SUCCESS'
+          set_errors(response)
+          return false
+        end
+        
+        return true
+      else
+        set_errors(response)
+        return false
+      end
+    end
+  end
+end

data/lib/internetbs/domain_record.rb

@@ -0,0 +1,31 @@
+module InternetBS
+  class DomainRecord < Base
+    TYPES = ['A', 'AAAA', 'DYNAMIC', 'CNAME', 'MX', 'SRV', 'TXT', 'NS'].freeze
+    
+    attribute :name,     String
+    attribute :priority, Integer, :default => 10   # Used for MX type records (optional)
+    attribute :ttl,      Integer, :default => 3600 # 1 hour (optional)
+    attribute :type,     String  # One of DomainRecord::TYPES
+    attribute :value,    String
+    
+  # attribute :dyn_dns_login,    String  # Required for DYNAMIC records, ignored for all others, 1 - 30 chars
+  # attribute :dyn_dns_password, String  # Required for DYNAMIC records, ignored for all others, 1 - 30 chars
+  # attribute :at_registry,      Boolean # Only valid for .de & will be ignored for all other domains
+  
+    def valid?
+      ensure_attribute_has_value :full_record_name, :type, :value
+
+      if @type
+        unless TYPES.include?(@type.upcase!)
+          @errors << "type must be one of: #{TYPES.join(', ')}"
+        end
+      end
+
+      if @errors.any?
+        return false
+      else
+        return true
+      end
+    end
+  end
+end