mini-safe-gem 0.0.1

data/geocoder-1.8.6/lib/geocoder/lookups/amap.rb

@@ -0,0 +1,63 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/amap"
+
+module Geocoder::Lookup
+  class Amap < Base
+
+    def name
+      "AMap"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def supported_protocols
+      [:http]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      path = query.reverse_geocode? ? 'regeo' : 'geo'
+      "http://restapi.amap.com/v3/geocode/#{path}?"
+    end
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+      case [doc['status'], doc['info']]
+      when ['1', 'OK']
+        return doc['regeocodes'] unless doc['regeocodes'].blank?
+        return [doc['regeocode']] unless doc['regeocode'].blank?
+        return doc['geocodes'] unless doc['geocodes'].blank?
+      when ['0', 'INVALID_USER_KEY']
+        raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
+          Geocoder.log(:warn, "#{self.name} Geocoding API error: invalid api key.")
+      else
+        raise_error(Geocoder::Error, "server error.") ||
+          Geocoder.log(:warn, "#{self.name} Geocoding API error: server error - [#{doc['info']}]")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      params = {
+        :key => configuration.api_key,
+        :output => "json"
+      }
+      if query.reverse_geocode?
+        params[:location] = revert_coordinates(query.text)
+        params[:extensions] = "all"
+        params[:coordsys] = "gps"
+      else
+        params[:address] = query.sanitized_text
+      end
+      params.merge(super)
+    end
+
+    def revert_coordinates(text)
+      [text[1],text[0]].join(",")
+    end
+
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/amazon_location_service.rb

@@ -0,0 +1,58 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/amazon_location_service'
+
+module Geocoder::Lookup
+  class AmazonLocationService < Base
+    def results(query)
+      params = query.options.dup
+
+      # index_name is required
+      # Aws::ParamValidator raises ArgumentError on missing required keys
+      params.merge!(index_name: configuration[:index_name])
+
+      # Aws::ParamValidator raises ArgumentError on unexpected keys
+      params.delete(:lookup)
+
+      # Inherit language from configuration
+      params.merge!(language: configuration[:language])
+
+      resp = if query.reverse_geocode?
+        client.search_place_index_for_position(params.merge(position: query.coordinates.reverse))
+      else
+        client.search_place_index_for_text(params.merge(text: query.text))
+      end
+
+      resp.results
+    end
+
+    private
+
+    def client
+      return @client if @client
+      require_sdk
+      keys = configuration.api_key
+      if keys
+        @client = Aws::LocationService::Client.new(**{
+          region: keys[:region],
+          access_key_id: keys[:access_key_id],
+          secret_access_key: keys[:secret_access_key]
+        }.compact)
+      else
+        @client = Aws::LocationService::Client.new
+      end
+    end
+
+    def require_sdk
+      begin
+        require 'aws-sdk-locationservice'
+      rescue LoadError
+        raise_error(Geocoder::ConfigurationError) ||
+          Geocoder.log(
+            :error,
+            "Couldn't load the Amazon Location Service SDK. " +
+            "Install it with: gem install aws-sdk-locationservice -v '~> 1.4'"
+          )
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/azure.rb

@@ -0,0 +1,56 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/azure'
+
+module Geocoder::Lookup
+  class Azure < Base
+    def name
+      'Azure'
+    end
+
+    def required_api_key_parts
+      ['api_key']
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private
+
+    def base_query_url(query)
+      host = 'atlas.microsoft.com/search/address'
+
+      if query.reverse_geocode?
+        "#{protocol}://#{host}/reverse/json?"
+      else
+        "#{protocol}://#{host}/json?"
+      end
+    end
+
+    def query_url_params(query)
+      params = {
+        'api-version' => 1.0,
+        'language' => query.options[:language] || 'en',
+        'limit' => configuration[:limit] || 10,
+        'query' => query.sanitized_text,
+        'subscription-key' => configuration.api_key
+      }
+
+      params.merge(super)
+    end
+
+    def results(query)
+      return [] unless (doc = fetch_data(query))
+
+      return doc if doc['error']
+
+      if doc['results']&.any?
+        doc['results']
+      elsif doc['addresses']&.any?
+        doc['addresses']
+      else
+        []
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/baidu.rb

@@ -0,0 +1,63 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/baidu"
+
+module Geocoder::Lookup
+  class Baidu < Base
+
+    def name
+      "Baidu"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    # HTTP only
+    def supported_protocols
+      [:http]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.map.baidu.com/geocoder/v2/?"
+    end
+
+    def content_key
+      'result'
+    end
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+      case doc['status']
+      when 0
+        return [doc[content_key]] unless doc[content_key].blank?
+      when 1, 3, 4
+        raise_error(Geocoder::Error, "server error.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: server error.")
+      when 2
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid request.")
+      when 5
+        raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid api key.")
+      when 101, 102, 200..299
+        raise_error(Geocoder::RequestDenied, "request denied") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: request denied.")
+      when 300..399
+        raise_error(Geocoder::OverQueryLimitError, "over query limit.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: over query limit.")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      {
+        (query.reverse_geocode? ? :location : :address) => query.sanitized_text,
+        :ak => configuration.api_key,
+        :output => "json"
+      }.merge(super)
+    end
+
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/baidu_ip.rb

@@ -0,0 +1,30 @@
+require 'geocoder/lookups/baidu'
+require 'geocoder/results/baidu_ip'
+
+module Geocoder::Lookup
+  class BaiduIp < Baidu
+
+    def name
+      "Baidu IP"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.map.baidu.com/location/ip?"
+    end
+
+    def content_key
+      'content'
+    end
+
+    def query_url_params(query)
+      {
+        :ip => query.sanitized_text,
+        :ak => configuration.api_key,
+        :coor => "bd09ll"
+      }.merge(super)
+    end
+
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/ban_data_gouv_fr.rb

@@ -0,0 +1,143 @@
+# encoding: utf-8
+
+require 'geocoder/lookups/base'
+require 'geocoder/results/ban_data_gouv_fr'
+
+module Geocoder::Lookup
+  class BanDataGouvFr < Base
+
+    def name
+      "Base Adresse Nationale Française"
+    end
+
+    def map_link_url(coordinates)
+      "https://www.openstreetmap.org/#map=19/#{coordinates.join('/')}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      method = query.reverse_geocode? ? "reverse" : "search"
+      "#{protocol}://data.geopf.fr/geocodage/#{method}/?"
+    end
+
+    def any_result?(doc)
+      doc['features'] and doc['features'].any?
+    end
+
+    def results(query)
+      if doc = fetch_data(query) and any_result?(doc)
+        [doc]
+      else
+        []
+      end
+    end
+
+    #### PARAMS ####
+
+    def query_url_params(query)
+      query_ban_datagouv_fr_params(query).merge(super)
+    end
+
+    def query_ban_datagouv_fr_params(query)
+      query.reverse_geocode? ? reverse_geocode_ban_fr_params(query) : search_geocode_ban_fr_params(query)
+    end
+
+    #### SEARCH GEOCODING PARAMS ####
+    #
+    #  :q             =>    required, full text search param)
+
+    #  :limit         =>    force limit number of results returned by raw API
+    #                       (default = 5) note : only first result is taken
+    #                       in account in geocoder
+    #
+    #  :autocomplete  =>    pass 0 to disable autocomplete treatment of :q
+    #                       (default = 1)
+    #
+    #  :lat           =>    force filter results around specific lat/lon
+    #
+    #  :lon           =>    force filter results around specific lat/lon
+    #
+    #  :type          =>    force filter the returned result type
+    #                       (check results for a list of accepted types)
+    #
+    #  :postcode      =>    force filter results on a specific city post code
+    #
+    #  :citycode      =>    force filter results on a specific city UUID INSEE code
+    #
+    #  For up to date doc (in french only) : https://adresse.data.gouv.fr/api/
+    #
+    def search_geocode_ban_fr_params(query)
+      params = {
+        q: query.sanitized_text
+      }
+      unless (limit = query.options[:limit]).nil? || !limit_param_is_valid?(limit)
+        params[:limit] = limit.to_i
+      end
+      unless (autocomplete = query.options[:autocomplete]).nil? || !autocomplete_param_is_valid?(autocomplete)
+        params[:autocomplete] = autocomplete.to_s
+      end
+      unless (type = query.options[:type]).nil? || !type_param_is_valid?(type)
+        params[:type] = type.downcase
+      end
+      unless (postcode = query.options[:postcode]).nil? || !code_param_is_valid?(postcode)
+        params[:postcode] = postcode.to_s
+      end
+      unless (citycode = query.options[:citycode]).nil? || !code_param_is_valid?(citycode)
+        params[:citycode] = citycode.to_s
+      end
+      unless (lat = query.options[:lat]).nil? || !latitude_is_valid?(lat)
+        params[:lat] = lat
+      end
+      unless (lon = query.options[:lon]).nil? || !longitude_is_valid?(lon)
+        params[:lon] = lon
+      end
+      params
+    end
+
+    #### REVERSE GEOCODING PARAMS ####
+    #
+    #  :lat           =>    required
+    #
+    #  :lon           =>    required
+    #
+    #  :type          =>    force returned results type
+    #                       (check results for a list of accepted types)
+    #
+    def reverse_geocode_ban_fr_params(query)
+      lat_lon = query.coordinates
+      params = {
+          lat: lat_lon.first,
+          lon: lat_lon.last
+      }
+      unless (type = query.options[:type]).nil? || !type_param_is_valid?(type)
+        params[:type] = type.downcase
+      end
+      params
+    end
+
+    def limit_param_is_valid?(param)
+      param.to_i.positive?
+    end
+
+    def autocomplete_param_is_valid?(param)
+      [0,1].include?(param.to_i)
+    end
+
+    def type_param_is_valid?(param)
+      %w(housenumber street locality municipality).include?(param.downcase)
+    end
+
+    def code_param_is_valid?(param)
+      (1..99999).include?(param.to_i)
+    end
+
+    def latitude_is_valid?(param)
+      param.to_f <= 90 && param.to_f >= -90
+    end
+
+    def longitude_is_valid?(param)
+      param.to_f <= 180 && param.to_f >= -180
+    end
+  end
+end