whoisxmlapi 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 453ac4268c148b920859e950c1d32a21d7980a3b1800871121e1e45e43f82279
-  data.tar.gz: af4d3856d0df53f393c15fa9f78797a5a29806d216e6581aeda0edf6d491ea40
+  metadata.gz: fe3b9a00715ebd01c80e1378d9f64c57051f4af98848fe8fba3b548dac9716c4
+  data.tar.gz: 4cbb2e345411dd433820b4ec4c465635e4cbb6c13ac4ae687175ada3d776c64d
 SHA512:
-  metadata.gz: 674d3238730704987c9b848bc93fe2ff6817ebb24ad60a88f0aad4a99a4940c2b89681c8f55e0fac6de6629435120b8a89d362e73fff84661599603a20f1b158
-  data.tar.gz: a8ac668ed1e44e9bf6762e1e21dbf0393d46dfd8299add120cd1496b194d6c7d75e61e2cc9ed39c077b688ed251b3c650f5efd1d3c8cc92a80e38c96a540d8ff
+  metadata.gz: c6be612f3c774ad9d4a0511c49bc3a78cf53b3cc592fcd47c02a7c94423be084d3ce54728f5b96b9a568194c76a4ed6d912a6ab101b9576cdef937cc45c73f22
+  data.tar.gz: ebe16297aa08021577cecca96c15be662cb0da4995940ccf9bcb7041ca2047854d720281434bdfd88b0c02af496e61c22ff7527d891419d02b6ea333e20c1d92

data/lib/whoisxmlapi/client.rb

@@ -7,74 +7,126 @@ 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}."
+            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)
+            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}\'."
+        resp = JSON.parse(r.parsed_response)
+      else
+        resp = r.parsed_response
+      end
+
+      resp["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 +134,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 +158,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.new(: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']
-        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.new(: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']
-          else
-            res.domains = []
-          end
-        else
-          WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - no domains found for #{entity_name}!"
-          res.domains = []
-        end
-        res.save
-        if res.errors.any?
-          WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - ERROR saving RWhoisResult: #{res.errors.full_messages.join('; ')} - #{res}!"
         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 +239,30 @@ 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.response.is_a? Net::HTTPOK
+        if r && 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."
+            JSON.parse(r.parsed_response)
+          end
 
-      r ? r.parsed_response : nil
+          if r.parsed_response["error"]
+            result = {:error => {message: r.parsed_response["error"]}}
+          elsif r.parsed_response["data"]
+            result = {}
+            r.parsed_response["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/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,12 +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
 
-    # https://blog.bigbinary.com/2016/02/15/rails-5-makes-belong-to-association-required-by-default.html
-    belongs_to :whoisable, :polymorphic => true, optional: true
     # Actual indexing is performed in db_mongoid_extend.rake
     # index([
     #   [ :whoisable_id, Mongo::ASCENDING ],
@@ -28,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
@@ -64,15 +66,41 @@ module WhoisXMLAPI
       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

@@ -5,9 +5,10 @@ module WhoisXMLAPI
 
     # 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
-    field :entity_name, :type => String   # , index: true 
-    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.6"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whoisxmlapi
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - David Hillard
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-19 00:00:00.000000000 Z
+date: 2020-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport