whoisxmlapi 0.0.21 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ac00a12274c2c4684377a10db0f3a87bbcbc2ed0
-  data.tar.gz: f421c29dc23151e97f24fa2658a50f573db263c2
+SHA256:
+  metadata.gz: 19ef89481b853c23afd17b496d79abf4075a6ff4757ceafb33b67ee902b1ea6a
+  data.tar.gz: 35c3eeb9ac3ae90c776135f863a96812b2ec8ff65a0bff66b331a1bb1c5bf324
 SHA512:
-  metadata.gz: f3a5f9cd436a2063035e9af20b59dc16c7fb2e470a9fb1f60a8228314935ea3bda8130a6ea434d6e1b3375cf75c09c223ccf2e1474d21649f37191866857ec93
-  data.tar.gz: 5089ef2e920206344d69e0596297d5cc76812b5337a7315f360486793897e181e32c51529cab2e77d8c0b69bfd62a8ba565d971025cfdfbd266ebb02a670454d
+  metadata.gz: a6be70457f7c5291f1b23cbaf2210fd559df5bbdf7a1616ed9e92655859d11fb1ad20e2914c9efdd5c908769a9175fcb71244e4357ac772b543d3ec6a491bb0b
+  data.tar.gz: 79c9a1d03097cd8cb69ecf29714e189053a36420ae2177f3578d057eaab8407b4dddb20d23a3c2994b55c1d75537e4fd6c96ec088a4a5087c7079a0d121754b7

data/lib/whoisxmlapi.rb

@@ -9,38 +9,43 @@ require_relative "./whoisxmlapi/client"
 require_relative "./whoisxmlapi/rwhois_result"
 
 module WhoisXMLAPI
-  def self.domain
-    @domain
+
+  def self.whois_path=(path)
+    @whois_path = path
   end
 
-  def self.domain=(dom)
-    @domain = dom
+  def self.whois_path
+    @whois_path ? @whois_path : "https://www.whoisxmlapi.com/whoisserver/WhoisService"
   end
 
-  def self.username
-    @username
+
+  def self.rwhois_path=(path)
+    @rwhois_path = path
   end
 
-  def self.username=(uname)
-    @username = uname
+  def self.rwhois_path
+    @rwhois_path ? @rwhois_path : "https://reverse-whois-api.whoisxmlapi.com/api/v2"
   end
 
-  def self.password
-    @password
+
+  def self.account_path=(path)
+    @account_path = path
   end
 
-  def self.password=(pass)
-    @password = pass
+  def self.account_path
+    @account_path ? @account_path : "https://user.whoisxmlapi.com/service/account-balance"
   end
-  
+
+
   def self.api_key
     @api_key
   end
-  
+
   def self.api_key=(key)
     @api_key = key
   end
 
+
   def self.cache_length=(leng)
     @cache_length = leng
   end
@@ -49,6 +54,7 @@ module WhoisXMLAPI
     @cache_length
   end
 
+
   def self.cache=(bool)
     @cache = bool
   end
@@ -57,6 +63,7 @@ module WhoisXMLAPI
     @cache.nil? or @cache.blank? ? true : @cache
   end
 
+
   def self.rwhois_mode=(mode)
     @rwhois_mode = mode
   end
@@ -65,6 +72,7 @@ module WhoisXMLAPI
     @rwhois_mode ? @rwhois_mode : 'sample_purchase'
   end
 
+
   def self.callbacks
     @callbacks ||= {}
     @callbacks[:whois] ||= []
@@ -72,6 +80,7 @@ module WhoisXMLAPI
     @callbacks
   end
 
+
   def self.logger
     @logger ||= Logger.new(STDOUT)
     @logger
@@ -81,7 +90,9 @@ module WhoisXMLAPI
     @logger = log
   end
 
+
   def self.configure
-      yield self
+    yield self
   end
+
 end

data/lib/whoisxmlapi/client.rb

@@ -7,6 +7,8 @@ module WhoisXMLAPI
 
   class Client
 
+    # https://whoisapi.whoisxmlapi.com/docs
+    # GET https://www.whoisxmlapi.com/whoisserver/WhoisService?apiKey=YOUR_API_KEY&domainName=google.com
     def whois(domain)
       unless PublicSuffix.valid?(domain)
         res = WhoisXMLAPI::BadDomain.new
@@ -15,33 +17,25 @@ module WhoisXMLAPI
       end
 
       query = WhoisXMLAPI::Result.where(:domain => domain)
-
-      if WhoisXMLAPI.cache
-        query = query.where(:created_at.gte => (Time.now - WhoisXMLAPI.cache_length))
-      end
-
+      query = query.where(:created_at.gte => (Time.now - WhoisXMLAPI.cache_length)) if WhoisXMLAPI.cache
       res = query.first
 
-      if res && res._type != "WhoisXMLAPI::Unavailable"
-        return res
-      else
-        xquery = {
-            :apiKey => WhoisXMLAPI.api_key,
-            :domainName => domain,
-            :outputFormat => 'JSON'
+      if res.nil? || res._type == "WhoisXMLAPI::Unavailable"
+        params = {
+          :apiKey => WhoisXMLAPI.api_key,
+          :domainName => domain,
+          :outputFormat => 'JSON'
         }
 
         begin
-          r = HTTParty.get("#{WhoisXMLAPI.domain}/whoisserver/WhoisService", :query => xquery, :timeout => 120)
-        rescue Exception => e
-          WhoisXMLAPI.logger.info("Error getting Whois info for #{domain}: #{e}")
+          r = HTTParty.get(WhoisXMLAPI.whois_path, :query => params, :timeout => 120)
+        rescue StandardError => e
+          WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Error getting Whois info for #{domain}: #{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
@@ -51,94 +45,99 @@ module WhoisXMLAPI
         # WhoisXML and HTTParty are sometimes returning a Hash and not a JSON string as requested,
         # which is causing an error of "no implicit conversion of Hash into String" when we call JSON.parse.
         # Logger message is to monitor whether WhoisXML and/or HTTParty will still return a string on occasion.
-        if r.parsed_response.is_a?(String)
-          WhoisXMLAPI.logger.debug "WhoisXML Whois method passed back parsed_response as a String instead of a Hash for #{domain}."
-          presponse = JSON.parse(r.parsed_response)
-        else
-          presponse = r.parsed_response
+        if r
+          if r.parsed_response.is_a?(String)
+            WhoisXMLAPI.logger.debug "WhoisXMLAPI#whois - WARNING: passed back parsed_response as a String instead of a Hash for #{domain}."
+            presponse = JSON.parse(r.parsed_response)
+          else
+            presponse = r.parsed_response
+          end
+          if presponse.key? 'ErrorMessage'
+            WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Error getting Whois info: #{presponse['ErrorMessage']['msg']}"
+            res = WhoisXMLAPI::Unavailable.new
+            res.parse(domain)
+          elsif (200..299).include? r.code.to_i
+            res = WhoisXMLAPI::Good.new
+            res.parse(presponse['WhoisRecord'])
+            res.save
+          end
         end
 
-        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}")
+        unless res
+          WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Unable to get Whois info for : #{domain}"
           res = WhoisXMLAPI::Unavailable.new
           res.parse(domain)
-          return res
         end
+
       end
+      return res
     end
 
 
+    def self.send_rwhois_request(entity_name)
+      params = {
+        :apiKey           => WhoisXMLAPI.api_key,
+        :searchType       => "current",
+        :mode             => WhoisXMLAPI.rwhois_mode,
+        :responseFormat   => 'json',
+        :basicSearchTerms => {
+          :include => [entity_name]  # must be an array of strings!
+        },
+      }
+      begin
+        # To DEBUG add ":debug_output => $stdout"
+        r = HTTParty.post(WhoisXMLAPI.rwhois_path, :body => params.to_json, :timeout => 120, :headers => {'Content-Type' => 'application/json'})
+      rescue StandardError => e
+        WhoisXMLAPI.logger.info "WhoisXMLAPI#rwhois - Error getting RWhois info for #{entity_name}: #{e}"
+        r = nil
+      end
+
+      if WhoisXMLAPI.callbacks[:rwhois]
+        WhoisXMLAPI.callbacks[:rwhois].each do |cb|
+          cb.call
+        end
+      end
+
+      return r
+    end
+
+
+    # https://reverse-whois-api.whoisxmlapi.com/docs
+    # POST https://reverse-whois-api.whoisxmlapi.com/api/v2
     def rwhois(entity_name)
       # entity_name is really the domain being passed in for Rwhois not the actual 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
+      query = query.where(:created_at.gte => (Time.now - WhoisXMLAPI.cache_length)) if WhoisXMLAPI.cache
       res = query.first
 
       if res
-        WhoisXMLAPI.logger.debug "WhoisXMLAPI rwhois - using cached rwhois data for #{entity_name}"
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - using cached rwhois data for #{entity_name}"
       else
-        WhoisXMLAPI.logger.debug "WhoisXMLAPI rwhois - no cached rwhois data for #{entity_name}"
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - no cached rwhois data for #{entity_name}"
         res = WhoisXMLAPI::RWhoisResult.create(:entity_name => entity_name)
 
-        params_basic = {
-          basicSearchTerms: {
-            :include => [entity_name], # must be an array of strings!
-            :search_type => "current"
-          },
-          :mode => WhoisXMLAPI.rwhois_mode,
-          :apiKey => WhoisXMLAPI.api_key,
-        }
-
-        r = WhoisXMLAPI::Client.create_and_send_rwhois_request(params_basic)
-
-        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']
+        r = WhoisXMLAPI::Client.send_rwhois_request(entity_name)
+        if r && r.parsed_response && r.parsed_response['domainsList']
+          res.domains = r.parsed_response['domainsList']
           res.save
         elsif PublicSuffix.valid?(entity_name)
+          # if no luck with what was passed in and we have a valid domain with TLD, try just the second-level domain.
           domain = PublicSuffix.parse(entity_name)
           domain_sld = domain.sld
-          Rails.logger.debug "WhoisXMLAPI rwhois - no domains found for domain #{entity_name}, trying #{domain_sld}"
+          WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - no domains found for domain #{entity_name}, trying #{domain_sld}"
           res = WhoisXMLAPI::RWhoisResult.create(:entity_name => domain_sld)
 
-          params_basic = {
-            basicSearchTerms: {
-              :include => [domain_sld], #must be an array of strings!
-              :search_type => "current"
-            },
-              :mode => WhoisXMLAPI.rwhois_mode,
-              :apiKey => WhoisXMLAPI.api_key,
-          }
-
-          r = WhoisXMLAPI::Client.create_and_send_rwhois_request(params_basic)
-
-          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']
+          r = WhoisXMLAPI::Client.send_rwhois_request(domain_sld)
+          if r && r.parsed_response && r.parsed_response['domainsList']
+            res.domains = r.parsed_response['domainsList']
             res.save
           else
             res.domains = []
             res.save
           end
         else
-          WhoisXMLAPI.logger.debug "WhoisXMLAPI rwhois - no domains found for #{entity_name}!"
+          WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - no domains found for #{entity_name}!"
           res.domains = []
           res.save
         end
@@ -148,19 +147,26 @@ module WhoisXMLAPI
 
 
     def exists?(domain)
-      xquery = {
-          :cmd => 'GET_DN_AVAILABILITY',
-          :domainName => domain,
-          :outputFormat => 'JSON',
-          :apiKey => WhoisXMLAPI.api_key
+      params = {
+        :cmd => 'GET_DN_AVAILABILITY',
+        :domainName => domain,
+        :outputFormat => 'JSON',
+        :apiKey => WhoisXMLAPI.api_key
       }
-      r = HTTParty.get("#{WhoisXMLAPI.domain}/whoisserver/WhoisService", :query => xquery, :timeout => 120)
+      begin
+        r = HTTParty.get(WhoisXMLAPI.whois_path, :query => params, :timeout => 120)
+      rescue StandardError => e
+        WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Error getting Whois info for #{domain}: #{e}"
+        res = WhoisXMLAPI::Unavailable.new
+        res.parse(domain)
+        return res
+      end
 
       # WhoisXML and HTTParty are sometimes returning a Hash and not a JSON string as requested,
       # which is causing an error of "no implicit conversion of Hash into String" when we call JSON.parse.
       # Logger message is to monitor whether WhoisXML and/or HTTParty will still return a string on occasion.
       if r.parsed_response.is_a?(String)
-        Rails.logger.debug "WhoisXML passed back parsed_response as a String instead of a Hash for #{domain}. Exists? method"
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#exists? - passed back parsed_response as a String instead of a Hash for #{domain}."
         resp = JSON.parse(r.parsed_response)
       else
         resp = r.parsed_response
@@ -170,39 +176,29 @@ module WhoisXMLAPI
     end
 
 
+    #
+    # GET https://user.whoisxmlapi.com/service/account-balance?apiKey=YOUR_API_KEY
     def account_balance
-      aquery = {
-          :servicetype => 'accountbalance',
-          :output_format => 'JSON',
-          :apiKey => WhoisXMLAPI.api_key
+      params = {
+        :apiKey => WhoisXMLAPI.api_key
       }
-      r = HTTParty.get("#{WhoisXMLAPI.domain}/accountServices.php", :query => aquery, :timeout => 120)
+
+      begin
+        r = HTTParty.get(WhoisXMLAPI.account_path, :query => params, :timeout => 120)
+      rescue StandardError => e
+        WhoisXMLAPI.logger.info "WhoisXMLAPI#account_balance - Error getting account_balance: #{e}"
+        r = nil
+      end
 
       # WhoisXML and HTTParty are sometimes returning a Hash and not a JSON string as requested,
       # which is causing an error of "no implicit conversion of Hash into String" when we call JSON.parse.
       # Logger message is to monitor whether WhoisXML and/or HTTParty will still return a string on occasion.
       if r.parsed_response.is_a?(String)
-        Rails.logger.debug "WhoisXML passed back parsed_response as a String instead of a Hash. Account_balance method"
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#account_balance - passed back parsed_response as a String instead of a Hash."
         JSON.parse(r.parsed_response)
-      else
-        r.parsed_response
       end
 
-    end
-    
-    def self.create_and_send_rwhois_request(params_basic)
-      uri = URI.parse('https://reverse-whois-api.whoisxmlapi.com/api/v2')
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      request = Net::HTTP::Post.new(uri.request_uri)
-      request.add_field('Content-Type', 'application/json')
-      request.add_field('Accept', 'application/json')
-      request.body = params_basic.to_json
-      r = http.request(request)
-      # used for debugging
-      # puts JSON.parse(r.body).to_yaml
-      return r
+      r ? r.parsed_response : nil
     end
 
 
@@ -212,5 +208,5 @@ module WhoisXMLAPI
 
 
   end  # of class Client
-  
+
 end # of module WhoisXMLAPI

data/lib/whoisxmlapi/version.rb

@@ -1,3 +1,3 @@
 module WhoisXMLAPI
-  VERSION = "0.0.21"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whoisxmlapi
 version: !ruby/object:Gem::Version
-  version: 0.0.21
+  version: 0.1.0
 platform: ruby
 authors:
 - Christopher Maujean
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-15 00:00:00.000000000 Z
+date: 2019-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -144,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: whoisxmlapi.com access