maxminder 1.0.0

data/lib/max_mind.rb

@@ -0,0 +1,36 @@
+require 'uri'
+require 'net/https'
+require 'logger'
+require 'timeout'
+
+require 'max_mind/enquiry'
+require 'max_mind/lookup'
+
+module MaxMind
+  
+  ## Exception class for generic errors.
+  class Error < StandardError; end
+  
+  ## Exception class for when connection to the max mind service fails.
+  class ConnectionError < Error; end
+  
+  class << self
+    ## Licence key for accessing the maxmind service. A trial key
+    ## can be requested from http://www.maxmind.com/app/ccv2r_signup
+    attr_accessor :licence_key
+    
+    ## The server (or servers) to accept your request
+    attr_accessor :endpoints
+    
+    ## Return a default array of end points if none are specified.
+    def endpoints
+      @endpoints || ["https://minfraud1.maxmind.com/app/ccv2r", "https://minfraud3.maxmind.com/app/ccv2r"]
+    end
+    
+    ## Return a logger object for this MaxMind interaction
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+  end
+  
+end

data/lib/max_mind/enquiry.rb

@@ -0,0 +1,120 @@
+module MaxMind
+  class Enquiry
+    
+    attr_accessor :attributes
+    
+    def initialize(attributes = {})
+      self.attributes = attributes if attributes.is_a?(Hash)
+    end
+    
+    ## The attributes here will be sent to max mind
+    def sendable_attributes
+      hash = Hash.new
+      for field, data in attributes
+        hash[mapping[field]] = data
+      end
+      hash['license_key'] = MaxMind.licence_key
+      hash
+    end
+    
+    ## Run the check and return a hash of responses from the server.
+    def lookup
+      MaxMind.logger.debug "Beginning lookups"
+      MaxMind.logger.debug "('#{sendable_attributes.inspect}')"
+      for endpoint in MaxMind.endpoints
+        MaxMind.logger.debug "Attempting lookup on #{endpoint}"
+        uri = URI.parse(endpoint)
+        req = Net::HTTP::Post.new(uri.path)
+        req.set_form_data(sendable_attributes)
+        res = Net::HTTP.new(uri.host, uri.port)
+        if uri.scheme == 'https'
+          res.use_ssl = true
+          res.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        
+        begin
+          case res = res.request(req)
+          when Net::HTTPSuccess
+            return Lookup.new(res.body)
+          else
+            MaxMind.logger.debug "Error on #{endpoint} (#{res.class.to_s})"
+            next
+          end
+        rescue Timeout::Error
+          MaxMind.logger.debug "Timed out connecting to #{endpoint}"
+          next
+        end
+      end
+      
+      false
+    end
+    
+    ## Set or get an attribute from the attributes hash or raise 
+    ## no method error if it doesn't exist in our mapping.
+    def method_missing(name, value = nil)
+      attribute_name = name.to_s.gsub(/\=\z/, '').to_sym
+      return super unless mapping.keys.include?(attribute_name)
+      value ? (attributes[attribute_name] = value) : attributes[attribute_name]
+    end
+    
+    ## Various methods to make setting fields in the attributes hash 
+    ## a little easier.
+    attr_reader :email, :username, :password
+    
+    def email=(value)
+      @email = value
+      self.attributes[:email_md5] = Digest::MD5.hexdigest(value)
+      self.attributes[:email_domain] = value.split('@', 2).last
+      value
+    end
+    
+    def username=(value)
+      @username = value
+      self.attributes[:username_md5] = Digest::MD5.hexdigest(value)
+      value
+    end
+    
+    def password=(value)
+      @password = value
+      self.attributes[:password_md5] = Digest::MD5.hexdigest(value)
+      value
+    end
+    
+    private
+    
+    ## This method returns a mapping of method names to the appropriate attribute
+    ## expected by the MaxMind API.
+    def mapping
+      {
+        :ip_address         => 'i',
+        :forwarded_ip       => 'forwardedIP',
+        
+        :city               => 'city',
+        :region             => 'region',
+        :postal             => 'postal',
+        :country            => 'country',
+
+        :shipping_address   => 'shipAddr',
+        :shipping_city      => 'shipCity',
+        :shipping_region    => 'shipRegion',
+        :shipping_postal    => 'shipPostal',
+        :shipping_country   => 'shipCountry',
+        
+        :email_domain       => 'domain',
+        :email_md5          => 'emailMD5',
+        :username_md5       => 'usernameMD5',
+        :password_md5       => 'passwordMD5',
+        
+        :bin                => 'bin',
+        :bin_name           => 'binName',
+        :bin_phone          => 'binPhone',
+        
+        :transaction_id     => 'txnID',
+        :session_id         => 'sessionID',
+        :user_agent         => 'user_agent',
+        :accept_language    => 'accept_language'
+      }
+    end
+    
+  end
+end

data/lib/max_mind/lookup.rb

@@ -0,0 +1,78 @@
+module MaxMind
+  class Lookup
+    
+    def initialize(raw)
+      @attributes = Hash.new
+      for key, value in raw.split(';').map{|r| r.split('=', 2)}
+        field_name, type = mapping[key]
+        @attributes[field_name] = parse_value(value, type)
+      end
+    end
+    
+    ## Return the appropriate attribute from the attributes hash.
+    def method_missing(name)
+      super unless mapping.values.map(&:first).include?(name.to_sym)
+      @attributes[name.to_sym]
+    end
+    
+    private
+    
+    ## This is the mapping of response attributes to their local variable name
+    ## and type of data which is expected.
+    def mapping
+      {
+        'countryMatch'            => [:country_match, :boolean],
+        'countryCode'             => [:country_code, :string],
+        'highRiskCountry'         => [:high_risk_country?, :boolean],
+        'distance'                => [:distance, :integer],
+        'ip_region'               => [:ip_region, :string],
+        'ip_city'                 => [:ip_city, :string],
+        'ip_latitude'             => [:ip_latitude, :decimal],
+        'ip_longitude'            => [:ip_longitude, :decimal],
+        'ip_isp'                  => [:ip_isp, :string],
+        'ip_org'                  => [:ip_organisation, :string],
+        'anonymousProxy'          => [:anonymous_proxy?, :boolean],
+        'proxyScore'              => [:proxy_score, :float],
+        'isTransProxy'            => [:transparent_proxy?, :boolean],
+        'freeMail'                => [:free_email?, :boolean],
+        'carderEmail'             => [:high_risk_email?, :boolean],
+        'highRiskUsername'        => [:high_risk_username?, :boolean],
+        'highRiskPassword'        => [:high_risk_password?, :boolean],
+        'binMatch'                => [:bin_match?, :boolean],
+        'binCountry'              => [:bin_country, :string],
+        'binNameMatch'            => [:bin_name_match?, :boolean],
+        'binName'                 => [:bin_name, :string],
+        'binPhoneMatch'           => [:bin_phone_match?, :boolean],
+        'binPhone'                => [:bin_phone, :string],
+        'custPhoneInBillingLoc'   => [:phone_in_billing_location?, :boolean],
+        'shipForward'             => [:mail_drop_address?, :boolean],
+        'cityPostalMatch'         => [:city_matches_postal?, :boolean],
+        'shipCityPostalMatch'     => [:ship_city_matches_postal?, :boolean],
+        'score'                   => [:score, :decimal],
+        'explanation'             => [:explanation, :string],
+        'riskScore'               => [:risk_score, :decimal],
+        'queriesRemaining'        => [:queries_remaining, :decimal],
+        'maxmindID'               => [:id, :string],
+        'err'                     => [:error, :string]
+      }
+    end
+    
+    ## Return a value as an instance of an appropriate ruby object.
+    def parse_value(value, type = :string)
+      case type
+      when :integer then value.to_i
+      when :decimal then value.to_f
+      when :boolean
+        case value
+        when 'Yes' then true
+        when 'No' then false
+        else
+          nil
+        end
+      else
+        value
+      end
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: maxminder
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Adam Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-05 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: adam@atechmedia.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/max_mind/enquiry.rb
+- lib/max_mind/lookup.rb
+- lib/max_mind.rb
+has_rdoc: false
+homepage: http://github.com/adamcooke/maxminder
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Simple (non-bloated) Ruby library for MaxMind
+test_files: []
+