whoisxmlapi 0.0.13

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in whoisxmlapi.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Christopher Maujean
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,104 @@
+# Whoisxmlapi
+
+Gem for accessing whoisxmlapi.com based on httparty and mongoid
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'whoisxmlapi'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install whoisxmlapi
+
+## Usage
+
+*Whois*
+
+    # config/initializers/whoisxmlapi.rb
+    WhoisXMLAPI.configure do |config|
+      config.username = ENV['WHOISXMLAPI_USERNAME']
+      config.password = ENV['WHOISXMLAPI_PASSWORD']
+      config.cache = true
+      config.cache_length = 1.minute
+    end
+
+    # elsewhere
+    wc = WhoisXMLAPI::Client.new
+    y = wc.whois("google.com")
+
+    # y should now be a WhoisXMLAPI::Result (or an exeption was thrown)
+    y.registrant.email
+    
+Associate your model with a whois record:
+
+    has_one :whois, as: :whoisable, autosave: true, class_name: "WhoisXMLAPI::Result"
+
+Now we can get at the data:
+
+    myinstance.whois.registrant.email
+
+*RWhois*
+
+    z = wc.rwhois(cmaujean@brandle.net)
+    z.domains
+
+Associate your model with a rwhois record:
+
+    has_one :rwhois, as: :rwhoisable, autosave: true, class_name: "WhoisXMLAPI::RWhoisResult"
+
+*Account Balance*
+
+Check your whoisxmlapi credits:
+
+    balance = wc.account_balance
+
+    # {
+    #  "balance"=>"464",
+    #  "reserve"=>"500",
+    #  "monthly_balance"=>"0",
+    #  "monthly_reserve"=>"0",
+    #  "reverse_whois_balance"=>"0",
+    #  "reverse_whois_reserve"=>"0",
+    #  "reverse_whois_monthly_balance"=>"0",
+    #  "reverse_whois_monthly_reserve"=>"0",
+    #  "ba_query_balance"=>nil,
+    #  "ba_query_reserve"=>nil,
+    #  "ra_query_balance"=>nil,
+    #  "ra_query_reserve"=>nil,
+    #  "ds_query_balance"=>nil,
+    #  "ds_query_reserve"=>nil
+    #  }
+
+
+*Callbacks*
+
+You can add callbacks to your whois and rwhois calls via the initializer:
+
+    config.callbacks[:whois] << Proc.new { SystemCumulativeStats.increment_whoisxmlapi_requests }
+    config.callbacks[:rwhois] << Proc.new { SystemCumulativeStats.increment_rwhoisxmlapi_requests }
+
+The callbacks will be called after the request to whoisxmlapi.com has been made. NOTE: Callback arguments are not currently supported.
+
+*Exists*
+
+Boolean check to see if a domain is registered.
+
+    wc.exists("foo.com")
+    #=> true
+
+    wc.exists("sdflsdfhwetewrw.com")
+    #=> false
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/whoisxmlapi.rb

@@ -0,0 +1,79 @@
+require_relative "./whoisxmlapi/version"
+require_relative "./whoisxmlapi/contact"
+require_relative "./whoisxmlapi/result"
+require_relative "./whoisxmlapi/good"
+require_relative "./whoisxmlapi/un_parsable"
+require_relative "./whoisxmlapi/bad_domain"
+require_relative "./whoisxmlapi/unavailable"
+require_relative "./whoisxmlapi/client"
+require_relative "./whoisxmlapi/rwhois_result"
+
+module WhoisXMLAPI
+  def self.domain
+    @domain
+  end
+
+  def self.domain=(dom)
+    @domain = dom
+  end
+
+  def self.username
+    @username
+  end
+
+  def self.username=(uname)
+    @username = uname
+  end
+
+  def self.password
+    @password
+  end
+
+  def self.password=(pass)
+    @password = pass
+  end
+
+  def self.cache_length=(leng)
+    @cache_length = leng
+  end
+
+  def self.cache_length
+    @cache_length
+  end
+
+  def self.cache=(bool)
+    @cache = bool
+  end
+
+  def self.cache
+    @cache.nil? or @cache.blank? ? true : @cache
+  end
+
+  def self.rwhois_mode=(mode)
+    @rwhois_mode = mode
+  end
+
+  def self.rwhois_mode
+    @rwhois_mode ? @rwhois_mode : 'sample_purchase'
+  end
+
+  def self.callbacks
+    @callbacks ||= {}
+    @callbacks[:whois] ||= []
+    @callbacks[:rwhois] ||= []
+    @callbacks
+  end
+
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+    @logger
+  end
+
+  def self.logger=(log)
+    @logger = log
+  end
+
+  def self.configure
+      yield self
+  end
+end

data/lib/whoisxmlapi/bad_domain.rb

@@ -0,0 +1,8 @@
+module WhoisXMLAPI
+  class BadDomain < WhoisXMLAPI::Result
+    def parse(domain)
+      self.domain = "#{domain} is invalid."
+      self.save
+    end
+  end
+end

data/lib/whoisxmlapi/client.rb

@@ -0,0 +1,153 @@
+require 'httparty'
+require 'active_support/core_ext'
+require 'json'
+require 'public_suffix'
+
+module WhoisXMLAPI
+  class Client
+    def whois(domain)
+      unless PublicSuffix.valid?(domain)
+        res = WhoisXMLAPI::BadDomain.new
+        res.parse(domain)
+        return res
+      end
+
+      query = WhoisXMLAPI::Result.where(:domain => domain)
+
+      if WhoisXMLAPI.cache
+        query = query.where(:created_at.gte => (Time.now - WhoisXMLAPI.cache_length))
+      end
+
+      res = query.first
+
+      if res && res._type != "WhoisXMLAPI::Unavailable"
+        return res
+      else
+        xquery = {
+            :domainName => domain,
+            :outputFormat => 'json', # TODO: make into a config setting. see the JSON.parse line below for the rest of this change
+            :userName => WhoisXMLAPI.username,
+            :password => WhoisXMLAPI.password
+        }
+        begin
+          r = HTTParty.get("#{WhoisXMLAPI.domain}/whoisserver/WhoisService", :query => xquery)
+        rescue Exception => e
+          WhoisXMLAPI.logger.info("Error getting Whois info: #{e}")
+          res = WhoisXMLAPI::Unavailable.new
+          res.parse(domain)
+          return res
+        end
+
+        res = WhoisXMLAPI::Good.new
+
+        if WhoisXMLAPI.callbacks[:whois]
+          WhoisXMLAPI.callbacks[:whois].each do |cb|
+            cb.call
+          end
+        end
+
+        # TODO: with the above outputFormat change, use a Parser plugin instead of this
+        presponse = JSON.parse(r.parsed_response)
+
+        if (200..299).include? r.code.to_i and not presponse.key? 'ErrorMessage'
+           res.parse(presponse['WhoisRecord'])
+           res.save
+           return res
+        else
+          WhoisXMLAPI.logger.info("Error getting Whois info: #{e}")
+          res = WhoisXMLAPI::Unavailable.new
+          res.parse(domain)
+          return res
+        end
+      end
+    end
+
+    def rwhois(entity_name)
+      return nil if entity_name.nil?
+      query = WhoisXMLAPI::RWhoisResult.where(:entity_name => entity_name)
+      if WhoisXMLAPI.cache
+        query = query.where(:created_at.gte => (Time.now - WhoisXMLAPI.cache_length))
+      end
+      res = query.first
+
+      if res
+        Rails.logger.debug "WhoisXMLAPI rwhois - have cached rwhois data for #{entity_name}"
+      else
+        Rails.logger.debug "WhoisXMLAPI rwhois - no cached rwhois data for #{entity_name}"
+        res = WhoisXMLAPI::RWhoisResult.create(:entity_name => entity_name)
+        rquery = {
+            :term1 => entity_name,
+            :search_type => 'current',
+            :mode => WhoisXMLAPI.rwhois_mode,
+            :username => WhoisXMLAPI.username,
+            :password => WhoisXMLAPI.password
+        }
+        r = HTTParty.get("#{WhoisXMLAPI.domain}/reverse-whois-api/search.php", :query => rquery)
+        if WhoisXMLAPI.callbacks[:rwhois]
+          WhoisXMLAPI.callbacks[:rwhois].each do |cb|
+            cb.call
+          end
+        end
+        if r && r.parsed_response && r.parsed_response['domains']
+          res.domains = r.parsed_response['domains']
+          res.save
+        elsif PublicSuffix.valid?(entity_name)
+          domain = PublicSuffix.parse(entity_name)
+          domain_sld = domain.sld
+          Rails.logger.debug "WhoisXMLAPI rwhois - no domains found for domain #{entity_name}, trying #{domain_sld}"
+          res = WhoisXMLAPI::RWhoisResult.create(:entity_name => domain_sld)
+          rquery = {
+              :term1 => domain_sld,
+              :search_type => 'current',
+              :mode => WhoisXMLAPI.rwhois_mode,
+              :username => WhoisXMLAPI.username,
+              :password => WhoisXMLAPI.password
+          }
+          r = HTTParty.get("#{WhoisXMLAPI.domain}/reverse-whois-api/search.php", :query => rquery)
+          if WhoisXMLAPI.callbacks[:rwhois]
+            WhoisXMLAPI.callbacks[:rwhois].each do |cb|
+              cb.call
+            end
+          end
+          if r && r.parsed_response && r.parsed_response['domains']
+            res.domains = r.parsed_response['domains']
+            res.save
+          else
+            res.domains = []
+            res.save
+          end
+        else
+          Rails.logger.debug "WhoisXMLAPI rwhois - no domains found for #{entity_name}!"
+          res.domains = []
+          res.save
+        end
+      end
+      res
+    end
+    
+    def exists?(domain)
+      xquery = {
+          :cmd => 'GET_DN_AVAILABILITY',
+          :domainName => domain,
+          :outputFormat => 'json',
+          :userName => WhoisXMLAPI.username,
+          :password => WhoisXMLAPI.password
+      }
+      r = HTTParty.get("#{WhoisXMLAPI.domain}/whoisserver/WhoisService", :query => xquery)
+
+      resp = JSON.parse(r.parsed_response)
+      resp["DomainInfo"]["domainAvailability"] == "UNAVAILABLE"
+    end
+
+    def account_balance
+      aquery = {
+          :servicetype => 'accountbalance',
+          :output_format => 'JSON',
+          :username => WhoisXMLAPI.username,
+          :password => WhoisXMLAPI.password
+      }
+      r = HTTParty.get("#{WhoisXMLAPI.domain}/accountServices.php", :query => aquery)
+      JSON.parse(r.parsed_response)
+    end
+  end
+end

data/lib/whoisxmlapi/contact.rb

@@ -0,0 +1,19 @@
+module WhoisXMLAPI
+  class Contact
+    include Mongoid::Document
+    include Mongoid::Timestamps
+
+    belongs_to :contactable, :polymorphic => true
+
+    field :name
+    field :organization
+    field :street1
+    field :street2
+    field :city
+    field :state
+    field :postalCode
+    field :country
+    field :email
+    field :telephone
+  end
+end

data/lib/whoisxmlapi/good.rb

@@ -0,0 +1,4 @@
+module WhoisXMLAPI
+  class Good < WhoisXMLAPI::Result
+  end
+end

data/lib/whoisxmlapi/result.rb

@@ -0,0 +1,67 @@
+require 'mongoid'
+
+module WhoisXMLAPI
+  class Result
+    include Mongoid::Document
+    include Mongoid::Timestamps
+
+    field :domain
+    field :record_created
+    field :record_updated
+    field :record_expires
+    field :registrar
+    field :nameservers, :type => Array
+
+    has_one :registrant, :as => :contactable, :class_name => "WhoisXMLAPI::Contact", :autosave => true
+    has_one :admin, :as => :contactable, :class_name => "WhoisXMLAPI::Contact", :autosave => true
+    has_one :tech, :as => :contactable, :class_name => "WhoisXMLAPI::Contact", :autosave => true
+    has_one :billing, :as => :contactable, :class_name => "WhoisXMLAPI::Contact", :autosave => true
+
+    belongs_to :whoisable, :polymorphic => true
+
+    def parse(record)
+      self.domain = record['domainName']
+
+      if record['registryData']
+        self.record_created = record['registryData']['createdDate']
+        self.record_updated = record['registryData']['updatedDate']
+        self.record_expires = record['registryData']['expiresDate']
+      else
+        res = WhoisXMLAPI::UnParsable.new
+        res.parse(record)
+        return res
+      end
+
+      self.registrar = record['registrarName']
+      self.nameservers = record['nameServers'] ? record['nameServers']['hostNames'] : (record['registryData'] && record['registryData']['nameServers'] ? record['registryData']['nameServers']['hostNames'] : nil)
+      registrant_data = record['registrant'] || (record['registryData'] ? record['registryData']['registrant'] : nil)
+
+      if registrant_data.nil?
+        res = WhoisXMLAPI::UnParsable.new
+        res.parse(record)
+        return res
+      end
+
+      # more "optional" data
+      administrative_data = record['administrativeContact'] || (record['registryData'] ? record['registryData']['administrativeContact'] : nil)
+      technical_data      = record['technicalContact'] || (record['registryData'] ? record['registryData']['technicalContact'] : nil)
+      billing_data        = record['billingContact'] || (record['registryData'] ? record['registryData']['billingContact'] : nil)
+
+      self.registrant = WhoisXMLAPI::Contact.create(registrant_data.merge({'email' => record['contactEmail']})) if registrant_data
+      self.admin      = WhoisXMLAPI::Contact.create(administrative_data) if administrative_data
+      self.tech       = WhoisXMLAPI::Contact.create(technical_data) if technical_data
+      self.billing    = WhoisXMLAPI::Contact.create(billing_data) if billing_data
+    end
+
+    def complete?
+      ( self.domain and self.registrar and ( self.registrant or self.admin or self.tech) )
+    end
+
+    def private?
+      %w/networksolutionsprivateregistration.com domainprivacygroup.com/.each do |priv|
+        return true if self.registrant.email =~ /#{priv}/
+      end
+      false
+    end
+  end
+end

data/lib/whoisxmlapi/rwhois_result.rb

@@ -0,0 +1,11 @@
+module WhoisXMLAPI
+  class RWhoisResult
+    include Mongoid::Document
+    include Mongoid::Timestamps
+
+    belongs_to :rwhoisable, :polymorphic => true
+    field :entity_name, :type => String
+    field :domains, :type => Array
+
+  end
+end

data/lib/whoisxmlapi/un_parsable.rb

@@ -0,0 +1,33 @@
+module WhoisXMLAPI
+  class UnParsable < WhoisXMLAPI::Result
+    def parse(record)
+      self.domain = record['domainName']
+
+      if record['registryData']
+        self.record_created = record['registryData']['createdDate']
+        self.record_updated = record['registryData']['updatedDate']
+        self.record_expires = record['registryData']['expiresDate']
+      end
+
+      self.registrar = record['registrarName']
+      self.nameservers = record['nameServers'] ? record['nameServers']['hostNames'] : []
+
+      registrant_data = record['registrant']
+
+      unless registrant_data
+        if record['registryData'] and record['registryData']['registrant']
+          registrant_data = record['registryData']['registrant']
+        else
+          registrant_data = {}
+        end
+      end
+      if record
+        registrant_data.merge({'email' => record['contactEmail']}) if record['contactEmail']
+        self.registrant = WhoisXMLAPI::Contact.create(registrant_data)
+        self.admin      = WhoisXMLAPI::Contact.create(record['administrativeContact']) if record['administrativeContact']
+        self.tech       = WhoisXMLAPI::Contact.create(record['technicalContact']) if record['technicalContact']
+        self.billing    = WhoisXMLAPI::Contact.create(record['billingContact']) if record['billingContact']
+      end
+    end
+  end
+end

data/lib/whoisxmlapi/unavailable.rb

@@ -0,0 +1,8 @@
+module WhoisXMLAPI
+  class Unavailable < WhoisXMLAPI::Result
+    def parse(domain)
+       self.domain = domain
+       self.save
+    end
+  end
+end

data/lib/whoisxmlapi/version.rb

@@ -0,0 +1,3 @@
+module WhoisXMLAPI
+  VERSION = "0.0.13"
+end

data/whoisxmlapi.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'whoisxmlapi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "whoisxmlapi"
+  spec.version       = WhoisXMLAPI::VERSION
+  spec.authors       = ["Christopher Maujean", "David Hillard"]
+  spec.email         = ["cmaujean@brandle.net"]
+  spec.description   = %q{Gem for accessing the Whois XML API via JSON, with caching}
+  spec.summary       = %q{whoisxmlapi.com access}
+  spec.homepage      = "http://brandle.net/"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "~> 3.2"
+  spec.add_dependency "mongoid"
+  spec.add_dependency "httparty"
+  spec.add_dependency "public_suffix"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: whoisxmlapi
+version: !ruby/object:Gem::Version
+  version: 0.0.13
+  prerelease: 
+platform: ruby
+authors:
+- Christopher Maujean
+- David Hillard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: public_suffix
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Gem for accessing the Whois XML API via JSON, with caching
+email:
+- cmaujean@brandle.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/whoisxmlapi.rb
+- lib/whoisxmlapi/bad_domain.rb
+- lib/whoisxmlapi/client.rb
+- lib/whoisxmlapi/contact.rb
+- lib/whoisxmlapi/good.rb
+- lib/whoisxmlapi/result.rb
+- lib/whoisxmlapi/rwhois_result.rb
+- lib/whoisxmlapi/un_parsable.rb
+- lib/whoisxmlapi/unavailable.rb
+- lib/whoisxmlapi/version.rb
+- whoisxmlapi.gemspec
+homepage: http://brandle.net/
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: whoisxmlapi.com access
+test_files: []