geocoder-kb 1.2.6

data/lib/geocoder/lookups/maxmind.rb

@@ -0,0 +1,90 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/maxmind'
+require 'csv'
+
+module Geocoder::Lookup
+  class Maxmind < Base
+
+    def name
+      "MaxMind"
+    end
+
+    def query_url(query)
+      "#{protocol}://geoip.maxmind.com/#{service_code}?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    ##
+    # Return the name of the configured service, or raise an exception.
+    #
+    def configured_service!
+      if s = configuration[:service] and services.keys.include?(s)
+        return s
+      else
+        raise(
+          Geocoder::ConfigurationError,
+          "When using MaxMind you MUST specify a service name: " +
+          "Geocoder.configure(:maxmind => {:service => ...}), " +
+          "where '...' is one of: #{services.keys.inspect}"
+        )
+      end
+    end
+
+    def service_code
+      services[configured_service!]
+    end
+
+    def service_response_fields_count
+      Geocoder::Result::Maxmind.field_names[configured_service!].size
+    end
+
+    def data_contains_error?(parsed_data)
+      # if all fields given then there is an error
+      parsed_data.size == service_response_fields_count and !parsed_data.last.nil?
+    end
+
+    ##
+    # Service names mapped to code used in URL.
+    #
+    def services
+      {
+        :country => "a",
+        :city => "b",
+        :city_isp_org => "f",
+        :omni => "e"
+      }
+    end
+
+    def results(query)
+      # don't look up a loopback address, just return the stored result
+      return [reserved_result] if query.loopback_ip_address?
+      doc = fetch_data(query)
+      if doc and doc.is_a?(Array)
+        if !data_contains_error?(doc)
+          return [doc]
+        elsif doc.last == "INVALID_LICENSE_KEY"
+          raise_error(Geocoder::InvalidApiKey) || warn("Invalid MaxMind API key.")
+        end
+      end
+      return []
+    end
+
+    def parse_raw_data(raw_data)
+      # Maxmind just returns text/plain as csv format but according to documentation,
+      # we get ISO-8859-1 encoded string. We need to convert it.
+      CSV.parse_line raw_data.force_encoding("ISO-8859-1").encode("UTF-8")
+    end
+
+    def reserved_result
+      ",,,,0,0,0,0,,,".split(",")
+    end
+
+    def query_url_params(query)
+      {
+        :l => configuration.api_key,
+        :i => query.sanitized_text
+      }.merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/maxmind_local.rb

@@ -0,0 +1,58 @@
+require 'ipaddr'
+require 'geocoder/lookups/base'
+require 'geocoder/results/maxmind_local'
+
+module Geocoder::Lookup
+  class MaxmindLocal < Base
+
+    def initialize
+      if !configuration[:file].nil?
+        begin
+          gem = RUBY_PLATFORM == 'java' ? 'jgeoip' : 'geoip'
+          require gem
+        rescue LoadError
+          raise "Could not load geoip dependency. To use MaxMind Local lookup you must add the #{gem} gem to your Gemfile or have it installed in your system."
+        end
+      end
+      super
+    end
+
+    def name
+      "MaxMind Local"
+    end
+
+    def required_api_key_parts
+      []
+    end
+
+    private
+
+    def results(query)
+      if configuration[:file]
+        geoip_class = RUBY_PLATFORM == "java" ? JGeoIP : GeoIP
+        result = geoip_class.new(configuration[:file]).city(query.to_s)
+        result.nil? ? [] : [result.to_hash]
+      elsif configuration[:package] == :city
+        addr = IPAddr.new(query.text).to_i
+        q = "SELECT l.country, l.region, l.city, l.latitude, l.longitude
+          FROM maxmind_geolite_city_location l WHERE l.loc_id = (SELECT b.loc_id FROM maxmind_geolite_city_blocks b
+          WHERE b.start_ip_num <= #{addr} AND #{addr} <= b.end_ip_num LIMIT 1)"
+        format_result(q, [:country_name, :region_name, :city_name, :latitude, :longitude])
+      elsif configuration[:package] == :country
+        addr = IPAddr.new(query.text).to_i
+        q = "SELECT country, country_code FROM maxmind_geolite_country
+          WHERE start_ip_num <= #{addr} AND #{addr} <= end_ip_num"
+        format_result(q, [:country_name, :country_code2])
+      end
+    end
+
+    def format_result(query, attr_names)
+      if r = ActiveRecord::Base.connection.execute(query).first
+        r = r.values if r.is_a?(Hash) # some db adapters return Hash, some Array
+        [Hash[*attr_names.zip(r).flatten]]
+      else
+        []
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/nominatim.rb

@@ -0,0 +1,52 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/nominatim"
+
+module Geocoder::Lookup
+  class Nominatim < Base
+
+    def name
+      "Nominatim"
+    end
+
+    def map_link_url(coordinates)
+      "http://www.openstreetmap.org/?lat=#{coordinates[0]}&lon=#{coordinates[1]}&zoom=15&layers=M"
+    end
+
+    def query_url(query)
+      method = query.reverse_geocode? ? "reverse" : "search"
+      host = configuration[:host] || "nominatim.openstreetmap.org"
+      "#{protocol}://#{host}/#{method}?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      doc.is_a?(Array) ? doc : [doc]
+    end
+
+    def parse_raw_data(raw_data)
+      if raw_data.include?("Bandwidth limit exceeded")
+        raise_error(Geocoder::OverQueryLimitError) || warn("Over API query limit.")
+      else
+        super(raw_data)
+      end
+    end
+
+    def query_url_params(query)
+      params = {
+        :format => "json",
+        :addressdetails => "1",
+        :"accept-language" => (query.language || configuration.language)
+      }.merge(super)
+      if query.reverse_geocode?
+        lat,lon = query.coordinates
+        params[:lat] = lat
+        params[:lon] = lon
+      else
+        params[:q] = query.sanitized_text
+      end
+      params
+    end
+  end
+end

data/lib/geocoder/lookups/okf.rb

@@ -0,0 +1,43 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/okf"
+
+module Geocoder::Lookup
+  class Okf < Base
+
+    def name
+      "Okf"
+    end
+
+    def query_url(query)
+      "#{protocol}://data.okf.fi/gis/1/geocode/json?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def valid_response?(response)
+      status = parse_json(response.body)["status"]
+      super(response) and ['OK', 'ZERO_RESULTS'].include?(status)
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      case doc['status']; when "OK" # OK status implies >0 results
+        return doc['results']
+      end
+      return []
+    end
+
+    def query_url_okf_params(query)
+      params = {
+        (query.reverse_geocode? ? :latlng : :address) => query.sanitized_text,
+        :sensor => "false",
+        :language => (query.language || configuration.language)
+      }
+      params
+    end
+
+    def query_url_params(query)
+      query_url_okf_params(query).merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/opencagedata.rb

@@ -0,0 +1,58 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/opencagedata'
+
+module Geocoder::Lookup
+  class Opencagedata < Base
+
+    def name
+      "OpenCageData"
+    end
+
+    def query_url(query)
+      "#{protocol}://api.opencagedata.com/geocode/v1/json?key=#{configuration.api_key}&#{url_query_string(query)}"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    private
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      # return doc["results"]
+
+      messages = doc['status']['message']
+      case doc['status']['code']
+      when 400 # Error with input
+        raise_error(Geocoder::InvalidRequest, messages) ||
+          warn("Opencagedata Geocoding API error: #{messages}")
+      when 403 # Key related error
+        raise_error(Geocoder::InvalidApiKey, messages) ||
+          warn("Opencagedata Geocoding API error: #{messages}")
+      when 402 # Quata Exceeded
+          raise_error(Geocoder::OverQueryLimitError, messages) ||
+          warn("Opencagedata Geocoding API error: #{messages}")
+      when 500 # Unknown error
+        raise_error(Geocoder::Error, messages) ||
+          warn("Opencagedata Geocoding API error: #{messages}")
+      end
+
+      return doc["results"]
+    end
+
+    def query_url_params(query)
+      params = {
+        :q => query.sanitized_text,
+        :language => (query.language || configuration.language)
+      }.merge(super)
+
+      unless (bounds = query.options[:bounds]).nil?
+        params[:bounds] = bounds.map{ |point| "%f,%f" % point }.join(',')
+      end
+
+      params
+    end
+
+  end
+end

data/lib/geocoder/lookups/ovi.rb

@@ -0,0 +1,62 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ovi'
+
+module Geocoder::Lookup
+  class Ovi < Base
+
+    def name
+      "Ovi"
+    end
+
+    def required_api_key_parts
+      []
+    end
+
+    def query_url(query)
+      "#{protocol}://lbs.ovi.com/search/6.2/#{if query.reverse_geocode? then 'reverse' end}geocode.json?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return [] unless doc['Response'] && doc['Response']['View']
+      if r=doc['Response']['View']
+        return [] if r.nil? || !r.is_a?(Array) || r.empty?
+        return r.first['Result']
+      end
+      []
+    end
+
+    def query_url_params(query)
+      options = {
+        :gen=>1,
+        :app_id=>api_key,
+        :app_code=>api_code
+      }
+
+      if query.reverse_geocode?
+        super.merge(options).merge(
+          :prox=>query.sanitized_text,
+          :mode=>:retrieveAddresses
+        )
+      else
+        super.merge(options).merge(
+          :searchtext=>query.sanitized_text
+        )
+      end
+    end
+
+    def api_key
+      if a=configuration.api_key
+        return a.first if a.is_a?(Array)
+      end
+    end
+
+    def api_code
+      if a=configuration.api_key
+        return a.last if a.is_a?(Array)
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/pointpin.rb

@@ -0,0 +1,68 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/pointpin'
+
+module Geocoder::Lookup
+  class Pointpin < Base
+
+    def name
+      "Pointpin"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def query_url(query)
+      "#{ protocol }://geo.pointp.in/#{ api_key }/json/#{ query.sanitized_text }"
+    end
+
+  private
+
+    def results(query)
+      # don't look up a loopback address, just return the stored result
+      return [] if query.loopback_ip_address?
+      doc = fetch_data(query)
+      if doc and doc.is_a?(Hash)
+        if !data_contains_error?(doc)
+          return [doc]
+        elsif doc['error']
+          case doc['error']
+          when "Invalid IP address"
+            raise_error(Geocoder::InvalidRequest) || warn("Invalid Pointpin request.")
+          when "Invalid API key"
+            raise_error(Geocoder::InvalidApiKey) || warn("Invalid Pointpin API key.")
+          when "Address not found"
+            warn("Address not found.")
+          end
+        else
+          raise_error(Geocoder::Error) || warn("Pointpin server error")
+        end
+      end
+      
+      return []
+    end
+
+    def data_contains_error?(parsed_data)
+      parsed_data.keys.include?('error')
+    end
+
+    def reserved_result(ip)
+      {
+        "ip"           => ip,
+        "city"         => "",
+        "region_code"  => "",
+        "region_name"  => "",
+        "metrocode"    => "",
+        "zipcode"      => "",
+        "latitude"     => "0",
+        "longitude"    => "0",
+        "country_name" => "Reserved",
+        "country_code" => "RD"
+      }
+    end
+
+    def api_key
+      configuration.api_key
+    end
+  end
+end

data/lib/geocoder/lookups/postcode_anywhere_uk.rb

@@ -0,0 +1,51 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/postcode_anywhere_uk'
+
+module Geocoder::Lookup
+  class PostcodeAnywhereUk < Base
+    # API documentation: http://www.postcodeanywhere.co.uk/Support/WebService/Geocoding/UK/Geocode/2/
+    BASE_URL_GEOCODE_V2_00 = 'services.postcodeanywhere.co.uk/Geocoding/UK/Geocode/v2.00/json.ws'
+    DAILY_LIMIT_EXEEDED_ERROR_CODES = ['8', '17'] # api docs say these two codes are the same error
+    INVALID_API_KEY_ERROR_CODE = '2'
+
+    def name
+      'PostcodeAnywhereUk'
+    end
+
+    def required_api_key_parts
+      %w(key)
+    end
+
+    def query_url(query)
+      format('%s://%s?%s', protocol, BASE_URL_GEOCODE_V2_00, url_query_string(query))
+    end
+
+    private
+
+    def results(query)
+      response = fetch_data(query)
+      return [] if response.nil? || !response.is_a?(Array) || response.empty?
+
+      raise_exception_for_response(response[0]) if response[0]['Error']
+      response
+    end
+
+    def raise_exception_for_response(response)
+      case response['Error']
+      when *DAILY_LIMIT_EXEEDED_ERROR_CODES
+        raise_error(Geocoder::OverQueryLimitError, response['Cause']) || warn(response['Cause'])
+      when INVALID_API_KEY_ERROR_CODE
+        raise_error(Geocoder::InvalidApiKey, response['Cause']) || warn(response['Cause'])
+      else # anything else just raise general error with the api cause
+        raise_error(Geocoder::Error, response['Cause']) || warn(response['Cause'])
+      end
+    end
+
+    def query_url_params(query)
+      {
+        :location => query.sanitized_text,
+        :key => configuration.api_key
+      }.merge(super)
+    end
+  end
+end