whoisxmlapi 0.2.3 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7217317d0caf1be648ce6b96cef1c0b3c977bb90c65fa5d1e69cb6b181b36967
-  data.tar.gz: 8c77cd66f5a26dbf8e7e99b86e64a42c332fb234d69d2b35c89784e667930775
+  metadata.gz: 2442b889d8fed140f51f7d83bf621f30403d81bace0d7fa3f16db5fba1c61ba5
+  data.tar.gz: 248927a9e820129a2cb6bfe0ba3656de0e361d9624ca375f0896fd55f1a774f4
 SHA512:
-  metadata.gz: dd9344a0e3a271d1641f9e91a12c5cbe3f04dc12a5acad25a6db009313932cafd9aaa8fe455702d666335452211dae33c4a8e38715a9dd8343ba47acfed3fefc
-  data.tar.gz: 76e08efaf6aa25e334a9ee90dc20b10e3b500ab2ec571dc2a82aef2bcea2a36ae43d33ba2326e947ef6e16344db03e18b9ed1bca3d380cd9b3ee3ad91fd83208
+  metadata.gz: ba31775e1e05d8b9c482ab67b52858d401defa81b746a8e5a7913a6da3536f38c2786337c9d0c47cb402779d90408445cf98ac3ebc2b9fd526dacea03efad509
+  data.tar.gz: 1e9d36cf33a50560a604ffdf5085228dbb7ff51f53b4721568a5da72095b1f507e05e97de5babd48149795bdfab5b6baedae7f822c5c0afc703711106612bcc2

data/lib/whoisxmlapi/client.rb

@@ -7,74 +7,129 @@ module WhoisXMLAPI
 
   class Client
 
+    ####################################################################################################
+    # Whois
+    ####################################################################################################
+
     # https://whoisapi.whoisxmlapi.com/docs
     # GET https://www.whoisxmlapi.com/whoisserver/WhoisService?apiKey=YOUR_API_KEY&domainName=google.com
-    def whois(domain)
+    def whois_cacheless(domain, owner=nil)
       unless PublicSuffix.valid?(domain)
-        res = WhoisXMLAPI::BadDomain.new
+        res = WhoisXMLAPI::BadDomain.new(:whoisable => owner)
         res.parse(domain)
         return res
       end
 
-      query = WhoisXMLAPI::Result.where(:domain => domain)
-      query = query.where(:created_at.gte => (Time.now - WhoisXMLAPI.cache_length)) if WhoisXMLAPI.cache
-      res = query.first
-
-      if res.nil? || res._type == "WhoisXMLAPI::Unavailable"
-        params = {
-          :apiKey => WhoisXMLAPI.api_key,
-          :domainName => domain,
-          :outputFormat => 'JSON'
-        }
-
-        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
+      params = {
+        :apiKey => WhoisXMLAPI.api_key,
+        :domainName => domain,
+        :outputFormat => 'JSON'
+      }
 
+      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(:whoisable => owner)
+        res.parse(domain)     # parse will save document for Unavailable
+      else
         if WhoisXMLAPI.callbacks[:whois]
-          WhoisXMLAPI.callbacks[:whois].each do |cb|
-            cb.call
-          end
+          WhoisXMLAPI.callbacks[:whois].each{ |cb| cb.call }
         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
           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)
+            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) rescue nil
           else
             presponse = r.parsed_response
           end
-          if presponse.key? 'ErrorMessage'
+
+          if presponse.nil?
+            res = {:error => {message: 'Failed to parse response from API.'}}
+          elsif presponse.key? 'ErrorMessage'
             WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Error getting Whois info: #{presponse['ErrorMessage']['msg']}"
-            res = WhoisXMLAPI::Unavailable.new
-            res.parse(domain)
+            res = WhoisXMLAPI::Unavailable.new(:whoisable => owner)
+            res.parse(domain)                     # parse will save document for Unavailable
           elsif (200..299).include? r.code.to_i
-            res = WhoisXMLAPI::Good.new
-            res.parse(presponse['WhoisRecord'])
+            res = WhoisXMLAPI::Good.new(:whoisable => owner)
+            res.parse(presponse['WhoisRecord'])   # parse will NOT save document for Good or UnParsable
             res.save
           end
         end
+      end
 
-        unless res
-          WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Unable to get Whois info for : #{domain}"
-          res = WhoisXMLAPI::Unavailable.new
-          res.parse(domain)
-        end
-
+      unless res
+        WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Unable to get Whois info for domain: \'#{domain}\'"
+        res = WhoisXMLAPI::Unavailable.new(:whoisable => owner)
+        res.parse(domain)   # parse will save document for Unavailable
       end
+
       return res
     end
 
 
-    def self.send_rwhois_request(entity_name)
+    # https://whoisapi.whoisxmlapi.com/docs
+    # GET https://www.whoisxmlapi.com/whoisserver/WhoisService?apiKey=YOUR_API_KEY&domainName=google.com
+    def whois(domain, owner=nil)
+      unless PublicSuffix.valid?(domain)
+        res = WhoisXMLAPI::BadDomain.new
+        res.parse(domain)
+        return res
+      end
+
+      query = WhoisXMLAPI::Result.where(:domain => domain)
+      query = query.where(:created_at.gte => (Time.now - WhoisXMLAPI.cache_length)) if WhoisXMLAPI.cache
+      res = query.first
+
+      if res.nil? || res._type == "WhoisXMLAPI::Unavailable"
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#whois - no cached Whois data for \'#{domain}\': initiating API access."
+        res = whois_cacheless(domain, owner)
+      else
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#whois - using cached Whois data for \'#{domain}\'"
+      end
+      res
+    end
+
+
+    def exists?(domain)
+      params = {
+        :cmd => 'GET_DN_AVAILABILITY',
+        :domainName => domain,
+        :outputFormat => 'JSON',
+        :apiKey => WhoisXMLAPI.api_key
+      }
+      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)
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#exists? - passed back parsed_response as a String instead of a Hash for \'#{domain}\'."
+        presponse = JSON.parse(r.parsed_response) rescue nil
+      else
+        presponse = r.parsed_response
+      end
+
+      presponse && presponse["DomainInfo"]["domainAvailability"] == "UNAVAILABLE"
+    end
+
+
+    ####################################################################################################
+    # Reverse Whois
+    ####################################################################################################
+
+
+    def self.send_rwhois_request(entity_name, since_dt=nil)
       params = {
         :apiKey           => WhoisXMLAPI.api_key,
         :searchType       => "current",
@@ -82,13 +137,15 @@ module WhoisXMLAPI
         :responseFormat   => 'json',
         :basicSearchTerms => {
           :include => [entity_name]  # must be an array of strings!
-        },
+        }
       }
+      params[:createdDateFrom] = since_dt.strftime("%F") if since_dt
+
       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}"
+        WhoisXMLAPI.logger.info "WhoisXMLAPI#rwhois - Error getting RWhois info for \'#{entity_name}\': #{e}"
         r = nil
       end
 
@@ -104,81 +161,76 @@ module WhoisXMLAPI
 
     # https://reverse-whois-api.whoisxmlapi.com/docs
     # POST https://reverse-whois-api.whoisxmlapi.com/api/v2
-    def rwhois(entity_name)
+    def rwhois_cacheless(entity_name, since_dt=nil, owner=nil)
       # 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)
-      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}"
-      else
-        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - no cached rwhois data for #{entity_name}"
-        res = WhoisXMLAPI::RWhoisResult.create(:entity_name => entity_name)
-
-        r = WhoisXMLAPI::Client.send_rwhois_request(entity_name)
+      return nil unless entity_name.present?
+      res = WhoisXMLAPI::RWhoisResult.new(:entity_name => entity_name, :rwhoisable => owner, :domains => [])
+      r = WhoisXMLAPI::Client.send_rwhois_request(entity_name, since_dt)
+      if r && r.parsed_response && r.parsed_response['domainsList']
+        res.domains = r.parsed_response['domainsList']
+      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_sld = PublicSuffix.parse(entity_name).sld
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois_cacheless - no domains found for domain \'#{entity_name}\', trying #{domain_sld}"
+        res.entity_name = domain_sld
+        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
-        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
-          WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - no domains found for domain #{entity_name}, trying #{domain_sld}"
-          res = WhoisXMLAPI::RWhoisResult.create(:entity_name => domain_sld)
-
-          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}!"
-          res.domains = []
-          res.save
         end
+      else
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois_cacheless - no domains found for \'#{entity_name}\'!"
+      end
+      unless res.save
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois_cacheless - ERROR saving RWhoisResult: #{res.errors.full_messages.join('; ')} - #{res}!"
       end
       res
     end
 
 
-    def exists?(domain)
-      params = {
-        :cmd => 'GET_DN_AVAILABILITY',
-        :domainName => domain,
-        :outputFormat => 'JSON',
-        :apiKey => WhoisXMLAPI.api_key
-      }
-      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
+    # https://reverse-whois-api.whoisxmlapi.com/docs
+    # POST https://reverse-whois-api.whoisxmlapi.com/api/v2
+    def rwhois(entity_name, since_dt=nil, owner=nil)
+      # 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, :rwhoisable => owner)
+      query = query.where(:created_at.gte => (Time.now - WhoisXMLAPI.cache_length)) if WhoisXMLAPI.cache
+      res   = query.first
 
-      # 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 "WhoisXMLAPI#exists? - passed back parsed_response as a String instead of a Hash for #{domain}."
-        resp = JSON.parse(r.parsed_response)
+      if res.nil?
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - no cached RWhois data for \'#{entity_name}\': initiating API access."
+        res = rwhois_cacheless(entity_name, since_dt, owner)
       else
-        resp = r.parsed_response
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - using cached RWhois data for \'#{entity_name}\'"
       end
-
-      resp["DomainInfo"]["domainAvailability"] == "UNAVAILABLE"
+      res
     end
 
 
+    ####################################################################################################
+    # Account Balance
+    ####################################################################################################
+
+
     #
     # GET https://user.whoisxmlapi.com/service/account-balance?apiKey=YOUR_API_KEY
+    # wc.account_balance
+    # =>
+    # {
+    #   "Email Verification API"     => {:product_id => 7,  :credits => 1000},
+    #   "IP Geolocation API"         => {:product_id => 8,  :credits => 1000},
+    #   "Domain Research Suite"      => {:product_id => 14, :credits => 100},
+    #   "WHOIS API"                  => {:product_id => 1,  :credits => 1000},
+    #   "Domain Reputation API"      => {:product_id => 20, :credits => 100},
+    #   "IP Netblocks API"           => {:product_id => 23, :credits => 1000},
+    #   "Domain Availability API"    => {:product_id => 25, :credits => 100},
+    #   "Screenshot API"             => {:product_id => 27, :credits => 500},
+    #   "Website Categorization API" => {:product_id => 21, :credits => 100},
+    #   "Website Contacts API"       => {:product_id => 29, :credits => 100},
+    #   "DNS Lookup API"             => {:product_id => 26, :credits => 500}
+    # }
+
     def account_balance
+      result = nil
       params = {
         :apiKey => WhoisXMLAPI.api_key
       }
@@ -190,15 +242,34 @@ module WhoisXMLAPI
         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)
-        WhoisXMLAPI.logger.debug "WhoisXMLAPI#account_balance - passed back parsed_response as a String instead of a Hash."
-        JSON.parse(r.parsed_response)
-      end
+      if r && r.response.is_a?(Net::HTTPOK)
+        if r.parsed_response
+          # 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 "WhoisXMLAPI#account_balance - passed back parsed_response as a String instead of a Hash."
+            presponse = JSON.parse(r.parsed_response) rescue nil
+          else
+            presponse = r.parsed_response
+          end
 
-      r ? r.parsed_response : nil
+          if presponse.nil?
+            result = {:error => {message: 'Failed to parse response from API.'}}
+          elsif presponse["error"]
+            result = {:error => {message: presponse["error"]}}
+          elsif presponse["data"]
+            result = {}
+            presponse["data"].each do |datum|
+              key = datum["product"]["name"]
+              result[key] = {product_id: datum["product_id"], credits: datum["credits"]}
+            end
+          end
+        end
+      else
+        result = {:error =>{code: r.response.code, message: r.response.message}}
+      end
+      result
     end
 
 

data/lib/whoisxmlapi/contact.rb

@@ -23,5 +23,24 @@ module WhoisXMLAPI
     field :email
     field :telephone
     field :fax
+
+    def self.selectively_create_from_hash(h)
+      attr = {
+        :name         => h['name'],
+        :organization => h['organization'],
+        :street1      => h['street1'],
+        :street2      => h['street2'],
+        :city         => h['city'],
+        :state        => h['state'],
+        :postalCode   => h['postalCode'],
+        :country      => h['country'],
+        :countryCode  => h['countryCode'],
+        :email        => h['email'],
+        :telephone    => h['telephone'],
+        :fax          => h['fax'],
+      }
+      Contact.create(attr)
+    end
+
   end
 end

data/lib/whoisxmlapi/result.rb

@@ -5,6 +5,9 @@ module WhoisXMLAPI
     include Mongoid::Document
     include Mongoid::Timestamps
 
+    # https://blog.bigbinary.com/2016/02/15/rails-5-makes-belong-to-association-required-by-default.html
+    belongs_to :whoisable, :polymorphic => true, optional: true
+
     field :domain
     field :record_created
     field :record_updated
@@ -15,11 +18,10 @@ module WhoisXMLAPI
     field :status
 
     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
+    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
     # Actual indexing is performed in db_mongoid_extend.rake
     # index([
     #   [ :whoisable_id, Mongo::ASCENDING ],
@@ -27,6 +29,7 @@ module WhoisXMLAPI
     # ])
     index({whoisable_id: 1, whoisable_type: 1})
 
+
     def parse(record)
       self.domain = record['domainName']
       self.data_error = record['dataError'] ? record['dataError'] : nil
@@ -57,21 +60,47 @@ module WhoisXMLAPI
       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
+      self.registrant = WhoisXMLAPI::Contact.selectively_create_from_hash(registrant_data.merge({'email' => record['contactEmail']})) if registrant_data
+      self.admin      = WhoisXMLAPI::Contact.selectively_create_from_hash(administrative_data) if administrative_data
+      self.tech       = WhoisXMLAPI::Contact.selectively_create_from_hash(technical_data) if technical_data
+      self.billing    = WhoisXMLAPI::Contact.selectively_create_from_hash(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
+
+
+    def contact_email(contact)
+      case contact
+      when :registrant
+        registrant ? registrant.email : nil
+      when :admin
+        admin ? admin.email : nil
+      when :tech
+        tech ? tech.email : nil
+      when :billing
+        billing ? billing.email : nil
+      else
+        nil
+      end
+    end
+
+
+    def contact_email_host(contact)
+      email = contact_email(contact)
+      host = email.squish.split("@").last.downcase if email.present? && email.include?("@")
+      PublicSuffix.valid?(host) ? host : nil
+    end
+
   end
 end

data/lib/whoisxmlapi/rwhois_result.rb

@@ -3,16 +3,12 @@ module WhoisXMLAPI
     include Mongoid::Document
     include Mongoid::Timestamps
 
-    belongs_to :rwhoisable, :polymorphic => true
+    # https://blog.bigbinary.com/2016/02/15/rails-5-makes-belong-to-association-required-by-default.html
+    belongs_to :rwhoisable, :polymorphic => true, optional: true
+
     # Actual indexing is performed in db_mongoid_extend.rake
-    # index([
-    #   [ :rwhoisable_id, Mongo::ASCENDING ],
-    #   [ :rwhoisable_type, Mongo::ASCENDING ]
-    # ])
-    index({rwhoisable_id: 1, rwhoisable_type: 1})
-    
-    field :entity_name, :type => String
-    field :domains, :type => Array
 
+    field :entity_name, :type => String   # , index: true
+    field :domains,     :type => Array
   end
 end

data/lib/whoisxmlapi/version.rb

@@ -1,3 +1,3 @@
 module WhoisXMLAPI
-  VERSION = "0.2.3"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whoisxmlapi
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.1
 platform: ruby
 authors:
 - David Hillard
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-28 00:00:00.000000000 Z
+date: 2020-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport