registrar-client 0.1.0

data/lib/registrar/provider/enom/contact.rb

@@ -0,0 +1,68 @@
+module Registrar
+  module Provider
+    # :nodoc:
+    class Enom
+      # Contact object that wraps a generic contact and can be used to produce and parse
+      # wire-level representations of Enom contacts.
+      class Contact
+        attr_reader :contact
+
+        def initialize(contact)
+          raise ArgumentError, "Contact is required" unless contact
+          @contact = contact
+        end
+
+        def identifier
+          contact.identifier
+        end
+
+        def identifier=(identifier)
+          contact.identifier = identifier
+        end
+
+        # Returns a Hash that can be merged into a query.
+        # Type should be one of the following: Registrant, AuxBilling, Tech, Admin
+        def to_query(type)
+          {
+            "#{type}Address1" => contact.address_1,
+            "#{type}Address2" => contact.address_2,
+            "#{type}City" => contact.city,
+            "#{type}Country" => contact.country,
+            "#{type}EmailAddress" => contact.email,
+            "#{type}Fax" => contact.fax,
+            "#{type}FirstName" => contact.first_name,
+            "#{type}LastName" => contact.last_name,
+            "#{type}JobTitle" => contact.job_title,
+            "#{type}OrganizationName" => contact.organization_name,
+            "#{type}Phone" => contact.phone,
+            "#{type}PhoneExt" => contact.phone_ext,
+            "#{type}PostalCode" => contact.postal_code,
+            "#{type}StateProvince" => contact.state_province,
+            "#{type}StateProvinceChoice" => contact.state_province_choice
+          }
+        end
+
+        def self.from_response(type, attributes)
+          contact = Registrar::Contact.new
+          contact.identifier = attributes["#{type}PartyID"]
+          contact.address_1 = attributes["#{type}Address1"]
+          contact.address_2 = attributes["#{type}Address2"]
+          contact.city = attributes["#{type}City"]
+          contact.country = attributes["#{type}Country"]
+          contact.email = attributes["#{type}EmailAddress"]
+          contact.fax = attributes["#{type}Fax"]
+          contact.first_name = attributes["#{type}FirstName"]
+          contact.last_name = attributes["#{type}LastName"]
+          contact.job_title = attributes["#{type}JobTitle"]
+          contact.organization_name = attributes["#{type}OrganizationName"]
+          contact.phone = attributes["#{type}Phone"]
+          contact.phone_ext = attributes["#{type}PhoneExt"]
+          contact.postal_code = attributes["#{type}PostalCode"]
+          contact.state_province = attributes["#{type}StateProvince"]
+          contact.state_province_choice = attributes["#{type}StateProvinceChoice"]
+          self.new(contact)
+        end
+      end
+    end
+  end
+end

data/lib/registrar/provider/enom/extended_attribute.rb

@@ -0,0 +1,64 @@
+require 'registrar/provider/enom/extended_attribute_us'
+require 'registrar/provider/enom/extended_attribute_ca'
+require 'registrar/provider/enom/extended_attribute_io'
+
+module Registrar
+  module Provider
+    class Enom
+      # Wrapper around the generic extended attribute that resolves symbolic values
+      # to their Enom-specific values.
+      class ExtendedAttribute
+        include ExtendedAttributeUS
+        include ExtendedAttributeCA
+        include ExtendedAttributeIO
+      
+        attr_reader :extended_attribute
+        def initialize(extended_attribute)
+          @extended_attribute = extended_attribute
+        end
+
+        def name
+          resolve_name(extended_attribute.tld, extended_attribute.name)
+        end
+        def value
+          resolve_value(extended_attribute.tld, extended_attribute.value)
+        end
+
+        private
+        def resolve_name(tld, name)
+          case name
+          when Symbol then
+            names(tld)[name]
+          else
+            name
+          end
+        end
+
+        def names(tld)
+          {
+            'us' => us_names,
+            'ca' => ca_names,
+            'io' => io_names,
+          }[tld]
+        end
+
+        def resolve_value(tld, value)
+          case value
+          when Symbol then
+            values(tld)[value]
+          else
+            value
+          end
+        end
+
+        def values(tld)
+          {
+            'us' => us_values,
+            'ca' => ca_values,
+            'io' => io_values,
+          }[tld]
+        end
+      end
+    end
+  end
+end

data/lib/registrar/provider/enom/extended_attribute_ca.rb

@@ -0,0 +1,40 @@
+module Registrar
+  module Provider
+    class Enom
+      module ExtendedAttributeCA
+        protected
+        def ca_names
+          {
+            :"Legal Type" => 'cira_legal_type',
+            :"Agreement Version" => 'cira_agreement_version',
+            :"Agreement Value" => 'cira_agreement_value',
+          }
+        end
+        def ca_values
+          {
+            :"Aboriginal Peoples" => "ABO",
+            :"Canadian Citizen" => "CCT",
+            :"Canadian Resident" => "RES",
+            :"Corporation" => "CCO",
+            :"Educational" => "EDU",
+            :"Government Entity" => "GOV",
+            :"Hospital" => "HOP",
+            :"Indian Band" => "INB",
+            :"Legal Representative" => "LGR",
+            :"Library, Archive or Museum" => "LAM",
+            :"Official Mark" => "OMK",
+            :"Partnership" => "PRT",
+            :"Political Party" => "PLT",
+            :"The Queen" => "MAJ",
+            :"Trade Union" => "TRD",
+            :"Trade-mark" => "TDM",
+            :"Trust" => "TRS",
+            :"Unincorporated Association" => "ASS",
+            :"Yes" => "Y",
+            :"No" => "N",
+          }
+        end
+      end
+    end
+  end
+end

data/lib/registrar/provider/enom/extended_attribute_io.rb

@@ -0,0 +1,18 @@
+module Registrar
+  module Provider
+    class Enom
+      module ExtendedAttributeIO
+        def io_names
+          {
+            :"Renewal Agreement" => 'io_agreedelete'
+          }
+        end
+        def io_values
+          {
+            :"Yes" => 'YES'
+          }
+        end
+      end
+    end
+  end
+end

data/lib/registrar/provider/enom/extended_attribute_us.rb

@@ -0,0 +1,29 @@
+module Registrar
+  module Provider
+    class Enom
+      module ExtendedAttributeUS
+        def us_names
+          {
+            :Nexus => 'us_nexus',
+            :Purpose => 'us_purpose',
+            :Country => 'global_cc_us'
+          }
+        end
+        def us_values
+          {
+            :"US Citizen" => 'C11',
+            :"Business Entity" => 'C21',
+            :"Foreign Entity" => 'C31',
+            :"Permanent Resident" => 'C12',
+            :"US Based Office" => 'C22',
+            :"For Profit" => 'P1',
+            :"Non Profit" => 'P2',
+            :Personal => 'P3',
+            :Educational => 'P4',
+            :Government => 'P5',
+          }
+        end
+      end
+    end
+  end
+end

data/lib/registrar/provider/enom/order.rb

@@ -0,0 +1,41 @@
+module Registrar
+  module Provider
+    class Enom
+      # An Enom order.
+      class Order
+        attr_accessor :id
+        attr_accessor :order_status
+        attr_accessor :order_date
+        attr_accessor :status
+
+        def initialize(id)
+          @id = id
+        end
+
+        def status
+          @status || 'unknown'
+        end
+
+        def order_status
+          @order_status || 'unknown'
+        end
+
+        # Get a generic Registrar::Order object to use.
+        def to_order
+          order = Registrar::Order.new(id)
+          order.successful = status.downcase == "successful"
+          
+          order.status = case order_status.downcase
+          when 'open' then :open 
+          when 'closed' then :closed
+          else
+            order_status.downcase.to_sym
+          end
+
+          order.date = order_date 
+          order
+        end
+      end
+    end
+  end
+end

data/lib/registrar/provider/opensrs.rb

@@ -0,0 +1,133 @@
+require 'digest/md5'
+require 'builder'
+require 'nokogiri'
+require 'registrar/provider/opensrs/order'
+require 'registrar/provider/opensrs/operation'
+require 'registrar/provider/opensrs/contact'
+require 'registrar/provider/opensrs/contact_set'
+
+module Registrar
+  module Provider
+    # Implementation of a registrar provider for OpenSRS (http://www.opensrs.com/).
+    class OpenSRS
+      include HTTParty
+      format :xml
+      debug_output $stderr
+
+      attr_accessor :url, :username, :private_key
+
+      def initialize(url, username, private_key)
+        @url = url
+        @username = username
+        @private_key = private_key
+      end
+
+      def available?(name)
+        response = execute(lookup_operation(name).to_xml)
+
+        items = response['OPS_envelope']['body']['data_block']['dt_assoc']['item']
+        items = items.find { |item| item['dt_assoc'] }['dt_assoc']
+        items['item'][0] == 'available'
+      end
+
+      def purchase(name, registrant, purchase_options=nil)
+        purchase_options ||= Registrar::PurchaseOptions.new
+        response = execute(registration_operation(name, registrant, 
+                                                  purchase_options).to_xml)
+        order = check_order(response.body)
+        order.add_domain(name, registrant)
+        order.to_order
+      end
+
+      def renew(name, renewal_options)
+
+      end
+
+      def name_servers(name)
+        operation = Operation.new(:get, {
+          :domain => name, 
+          :type => "nameservers"
+        })
+        nameserver_list_from(execute(operation.to_xml).body)
+      end
+      alias :nameservers :name_servers
+
+      private
+      def nameserver_list_from(xml)
+        Nokogiri::XML(xml).xpath('//dt_array/item/dt_assoc/item[@key="name"]').map do |item|
+          Registrar::NameServer.new(item.content)
+        end
+      end
+
+      def check_order(xml)
+        order_info = execute(order_info_operation(order_id_from(xml)).to_xml)
+        Registrar::Provider::OpenSRS::Order.new(order_info.to_s)
+      end
+
+      def order_id_from(xml)
+        Nokogiri::XML(xml).xpath(
+          "//dt_assoc/item[@key='attributes']/dt_assoc/item[@key='id']").inner_text
+      end
+
+      def order_info_operation(id)
+        operation = Operation.new(:get_order_info, {
+          :order_id => id})
+      end
+
+      def lookup_operation(name)
+        operation = Operation.new(:lookup, {
+          :domain => name, 
+          :no_cache => "1"
+        })
+      end
+
+      def registration_operation(name, registrant, purchase_options)
+        operation = Operation.new(:sw_register, {
+          :domain => name,
+          :period => purchase_options.number_of_years,
+          :reg_type => "new",
+          :handle => 'process',
+          :reg_username => 'dnsimple',
+          :reg_password => 'password',
+          :custom_tech_contact => '1',
+          :custom_nameservers => '1',
+          :nameserver_list => nameserver_list(purchase_options),
+          :contact_set => contact_set(registrant),
+          :tld_data => tld_data(purchase_options)
+        })
+      end
+      
+      def nameserver_list(purchase_options)
+        NameServerList.new(purchase_options) if purchase_options
+      end
+
+      def tld_data(purchase_options)
+        TldData.build_with(purchase_options) if purchase_options && purchase_options.extended_attributes != []
+      end
+
+      def contact_set(registrant)
+        ContactSet.new({
+          'owner' => OpenSRS::Contact.new(registrant),
+          'admin' => OpenSRS::Contact.new(registrant),
+          'billing' => OpenSRS::Contact.new(registrant),
+          'tech' => OpenSRS::Contact.new(registrant)
+        })
+      end
+
+      def execute(body)
+        self.class.headers(
+          "Content-Type" => "text/xml",
+          "X-Username" => username,
+          "X-Signature" => signature(body),
+          "Content-Length" => body.length.to_s
+        )
+        self.class.post(url, {:body => body})
+      end
+
+      def signature(body)
+        step1 = Digest::MD5.hexdigest("#{body}#{private_key}")
+        Digest::MD5.hexdigest("#{step1}#{private_key}")
+      end
+    end
+  end
+end

data/lib/registrar/provider/opensrs/contact.rb

@@ -0,0 +1,30 @@
+module Registrar
+  module Provider
+    # :nodoc:
+    class OpenSRS
+      class Contact
+        attr_reader :contact
+
+        def initialize(contact)
+          raise ArgumentError, "Contact is required" unless contact
+          @contact = contact
+        end
+
+        def to_xml(builder)
+          builder.item(contact.first_name, :key => "first_name")
+          builder.item(contact.last_name, :key => "last_name")
+          builder.item(contact.phone, :key => "phone")
+          builder.item(contact.fax, :key => "fax")
+          builder.item(contact.email, :key => "email")
+          builder.item(contact.organization_name, :key => "org_name")
+          builder.item(contact.address_1, :key => "address1")
+          builder.item(contact.address_2, :key => "address2")
+          builder.item(contact.city, :key => "city")
+          builder.item(contact.state_province, :key => "state")
+          builder.item(contact.country, :key => "country")
+          builder.item(contact.postal_code, :key => "postal_code")
+        end
+      end
+    end
+  end
+end

data/lib/registrar/provider/opensrs/contact_set.rb

@@ -0,0 +1,24 @@
+module Registrar
+  module Provider
+    class OpenSRS
+      class ContactSet
+        attr_reader :contacts
+        def initialize(contacts)
+          @contacts = contacts
+        end
+
+        def to_xml(builder)
+          builder.dt_assoc { |b|
+            contacts.each do |key, contact|
+              b.item(:key => key.to_s) { |b|
+                b.dt_assoc { |b|
+                  contact.to_xml(b)
+                }
+              }
+            end
+          }
+        end
+      end
+    end
+  end
+end