google-api-customization 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: b844fe0fcf81c5a1f54cf739cc7c2f6fc7a81493
-  data.tar.gz: 6fcb775e21788a39358946d8887a85db49ce6506
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ODkxM2MzMjkzMzBlODg1MTg0OTVkMjRlNDY3Yjg1ZWI1YmFhMDhkZg==
+  data.tar.gz: !binary |-
+    NGNmMjAxMWJjYzE0NzU4MTc0MmMyYzYxMDVjZmQzNDMwZTFhNjNjZA==
 SHA512:
-  metadata.gz: daed10342f39dc9eca1f33d274f2e30cc78f247444437d5e37e77b0a128f0884d41d6c9a2acec91af1eea2e440457b24f24b9ebbb6d4ed56be5a35c26b3921b7
-  data.tar.gz: 15e6ed003b84b82a2f46c9e54cc4f250a6fe584d209b3c7c0d8f5c94a7276db94d3969aee90d089cea0fa98d1cd2311ab9972c4801c874cd0900026281cb2426
+  metadata.gz: !binary |-
+    NjgwYjI0YTUzYjRmYTFjZTRlOTViYzk0OTgzNWUwN2RhMGUyYjkzY2Y1ZWRj
+    OTRlM2NkMmY5MWFhZGJkYTE1OTM0N2U0MjRkMDc5ODM4ZWUxMjk2MTc1NjBj
+    NjExODAxZmUzOTIzNjk5ZDMyODU2MTc2M2NlZTNmODg2MzI2MGQ=
+  data.tar.gz: !binary |-
+    ZjljOGYwODRlNDhkYzQzMTE5NGU5MWU5M2NiOWVlNGI1ZjYwOGVjYjUxOTQy
+    MmI1YjQyMjI2Y2Q5OWIyOWVhY2M1MTU3ZDkwY2Q1NTRiNWM2NTI4ODZiZTIy
+    YTBkYWMwODMzYmM3ZGEyMzk2NWM2YTM0YTM5OGJlN2ZiYWRhMDk=

data/lib/google_api_customization.rb

@@ -1,7 +1,24 @@
-#require ''
-class GoogleApiCustomization
-  def self.hi
-    puts "Hello! Google Api Customization."
-  end 
+require 'debugger'
+require 'rubygems'
+require 'httparty'
+
+%w(request place api_key photo review).each do |file|
+  require File.join(File.dirname(__FILE__), 'google_api_customization', file)
 end
 
+
+module GoogleApiCustomization
+  
+  class << self
+
+    attr_accessor :api_key
+
+    def configuration
+      
+      yield self
+      
+    end
+
+  end
+
+end

data/lib/google_api_customization/place.rb

@@ -0,0 +1,207 @@
+module GoogleApiCustomization
+  
+  attr_accessor :lat, :lng, :viewport, :name, :icon, :reference, :vicinity, :types, :id, :formatted_phone_number, :international_phone_number, :formatted_address, :address_components, :street_number, :street, :city, :region, :postal_code, :country, :rating, :url, :cid, :website, :reviews, :aspects, :zagat_selected, :zagat_reviewed, :photos, :review_summary, :nextpagetoken, :price_level, :opening_hours, :events, :utc_offset, :place_id
+
+  class Place
+    
+    
+    def self.find(place_id, api_key, sensor, options = {})
+      language  = options.delete(:language)
+      retry_options = options.delete(:retry_options) || {}
+      extensions = options.delete(:review_summary) ? 'review_summary' : nil
+      
+      response = Request.place(
+                                {
+                                  :placeid => place_id,
+                                  :sensor => sensor,
+                                  :key => api_key,
+                                  :language => language,
+                                  :extensions => extensions,
+                                  :retry_options => retry_options
+                                }
+      )
+      
+      self.new(response['result'], api_key, sensor)
+    end    
+    
+
+    # Search for Spots with a pagetoken
+    #
+    # @return [Array<Spot>]
+    # @param [String] pagetoken the token to find next results
+    # @param [String] api_key the provided api key
+    # @param [Boolean] sensor
+    # @param [Hash] options
+    def self.list_by_pagetoken(pagetoken, api_key, sensor, options = {})
+      exclude = options.delete(:exclude) || []
+      exclude = [exclude] unless exclude.is_a?(Array)
+
+      options = {
+          :pagetoken => pagetoken,
+          :sensor => sensor,
+          :key => api_key
+      }
+
+      request(:spots_by_pagetoken, false, exclude, options)
+    end
+
+
+    def self.list_by_query(query, api_key, sensor, options = {})
+      if options.has_key?(:lat) && options.has_key?(:lng)
+        with_location = true
+      else
+        with_location = false
+      end
+
+      if options.has_key?(:radius)
+        with_radius = true
+      else
+        with_radius = false
+      end
+
+      query = query
+      sensor = sensor
+      multipage_request = !!options.delete(:multipage)
+      location = Location.new(options.delete(:lat), options.delete(:lng)) if with_location
+      radius = options.delete(:radius) if with_radius
+      rankby = options.delete(:rankby)
+      language = options.delete(:language)
+      types = options.delete(:types)
+      exclude = options.delete(:exclude) || []
+      retry_options = options.delete(:retry_options) || {}
+
+      exclude = [exclude] unless exclude.is_a?(Array)
+
+      options = {
+        :query => query,
+        :sensor => sensor,
+        :key => api_key,
+        :rankby => rankby,
+        :language => language,
+        :retry_options => retry_options
+      }
+
+      options[:location] = location.format if with_location
+      options[:radius] = radius if with_radius
+
+      # Accept Types as a string or array
+      if types
+        types = (types.is_a?(Array) ? types.join('|') : types)
+        options.merge!(:types => types)
+      end
+
+      request(:spots_by_query, multipage_request, exclude, options)
+    end
+
+    def self.request(method, multipage_request, exclude, options)
+      results = []
+
+      self.multi_pages_request(method, multipage_request, options) do |result|
+        # Some places returned by Google do not have a 'types' property. If the user specified 'types', then
+        # this is a non-issue because those places will not be returned. However, if the user did not specify
+        # 'types', then we do not want to filter out places with a missing 'types' property from the results set.
+        results << self.new(result, options[:key], options[:sensor]) if result['types'].nil? || (result['types'] & exclude) == []
+      end
+
+      results
+    end
+
+    
+    
+    def initialize(json_result_object, api_key, sensor)
+      @reference                  = json_result_object['reference']
+      @place_id                   = json_result_object['place_id']
+      @vicinity                   = json_result_object['vicinity']
+      @lat                        = json_result_object['geometry']['location']['lat']
+      @lng                        = json_result_object['geometry']['location']['lng']
+      @viewport                   = json_result_object['geometry']['viewport']
+      @name                       = json_result_object['name']
+      @icon                       = json_result_object['icon']
+      @types                      = json_result_object['types']
+      @id                         = json_result_object['id']
+      @formatted_phone_number     = json_result_object['formatted_phone_number']
+      @international_phone_number = json_result_object['international_phone_number']
+      @formatted_address          = json_result_object['formatted_address']
+      @address_components         = json_result_object['address_components']
+      @street_number              = address_component(:street_number, 'short_name')
+      @street                     = address_component(:route, 'long_name')
+      @city                       = address_component(:locality, 'long_name')
+      @region                     = address_component(:administrative_area_level_1, 'long_name')
+      @postal_code                = address_component(:postal_code, 'long_name')
+      @country                    = address_component(:country, 'long_name')
+      @rating                     = json_result_object['rating']
+      @price_level                = json_result_object['price_level']
+      @opening_hours              = json_result_object['opening_hours']
+      @url                        = json_result_object['url']
+      @cid                        = json_result_object['url'].to_i
+      @website                    = json_result_object['website']
+      @zagat_reviewed             = json_result_object['zagat_reviewed']
+      @zagat_selected             = json_result_object['zagat_selected']
+      @aspects                    = aspects_component(json_result_object['aspects'])
+      @review_summary             = json_result_object['review_summary']
+      @photos                     = photos_component(json_result_object['photos'], api_key, sensor)
+      @reviews                    = reviews_component(json_result_object['reviews'])
+      @nextpagetoken              = json_result_object['nextpagetoken']
+      @events                     = events_component(json_result_object['events'])
+      @utc_offset                 = json_result_object['utc_offset']
+    end
+    
+    def [] (key)
+      send(key)
+    end
+
+    
+    
+    
+    def address_component(address_component_type, address_component_length)
+      if component = address_components_of_type(address_component_type)
+        component.first[address_component_length] unless component.first.nil?
+      end
+    end
+    
+    def address_components_of_type(type)
+      @address_components.select{ |c| c['types'].include?(type.to_s) } unless @address_components.nil?
+    end
+    
+    def reviews_component(json_reviews)
+      if json_reviews
+        json_reviews.map { |r|
+          Review.new(
+              r['rating'],
+              r['type'],
+              r['author_name'],
+              r['author_url'],
+              r['text'],
+              r['time'].to_i
+          )
+        }
+      else []
+      end
+    end
+    
+    def aspects_component(json_aspects)
+      json_aspects.to_a.map{ |r| { :type => r['type'], :rating => r['rating'] } }
+    end
+
+    def photos_component(json_photos, api_key, sensor)
+      if json_photos
+        json_photos.map{ |p| 
+          Photo.new(
+            p['width'], 
+            p['height'],
+            p['photo_reference'],
+            p['html_attributions'], 
+            api_key, 
+            sensor
+          )
+        }
+      else []
+      end
+    end
+
+    def events_component(json_events)
+      json_events.to_a.map{ |r| {:event_id => r['event_id'], :summary => r['summary'], :url => r['url'], :start_time => r['start_time']} }
+    end
+    
+  end
+end

data/lib/google_api_customization/request.rb

@@ -0,0 +1,95 @@
+module GoogleApiCustomization
+  class Request
+    attr_accessor :response
+    attr_reader :options
+
+    include ::HTTParty
+    format :json
+        
+    
+    PLACES_URL                  =          "https://maps.googleapis.com/maps/api/place/details/json"
+
+    RADAR_SEARCH_URL            =          "https://maps.googleapis.com/maps/api/place/radarsearch/json"
+
+    TEXT_SEARCH_URL             =          "https://maps.googleapis.com/maps/api/place/textsearch/json"
+
+    NEARBY_SEARCH_URL           =          "https://maps.googleapis.com/maps/api/place/nearbysearch/json"
+
+    PHOTO_URL                   =          "https://maps.googleapis.com/maps/api/place/photo"
+
+    PAGETOKEN_URL               =          "https://maps.googleapis.com/maps/api/place/search/json"
+
+    RADAR_SEARCH_URL            =          "https://maps.googleapis.com/maps/api/place/radarsearch/json"
+
+    AUTOCOMPLETE_URL            =          "https://maps.googleapis.com/maps/api/place/autocomplete/json"
+     
+    def self.place(options = {})
+      request = new(PLACES_URL, options)
+      request.parsed_response
+    end
+    
+    def initialize(url, options, follow_redirects = true)
+      retry_options = options.delete(:retry_options) || {}
+
+      retry_options[:status] ||= []
+      retry_options[:max]    ||= 0
+      retry_options[:delay]  ||= 5
+
+      retry_options[:status] = [retry_options[:status]] unless retry_options[:status].is_a?(Array)
+      @response = self.class.get(url, :query => options, :follow_redirects => follow_redirects)
+
+      # puts @response.request.last_uri.to_s
+
+      return unless retry_options[:max] > 0 && retry_options[:status].include?(@response.parsed_response['status'])
+
+      retry_request = proc do
+        for i in (1..retry_options[:max])
+          sleep(retry_options[:delay])
+
+          @response = self.class.get(url, :query => options, :follow_redirects => follow_redirects)
+
+          break unless retry_options[:status].include?(@response.parsed_response['status'])
+        end
+      end
+
+      if retry_options[:timeout]
+        begin
+          Timeout::timeout(retry_options[:timeout]) do
+            retry_request.call
+          end
+        rescue Timeout::Error
+          raise RetryTimeoutError.new(@response)
+        end
+      else
+        retry_request.call
+
+        raise RetryError.new(@response) if retry_options[:status].include?(@response.parsed_response['status'])
+      end
+    end
+
+
+    def parsed_response
+    
+      return @response.headers["location"] if @response.code >= 300 and @response.code < 400
+      case @response.parsed_response['status']
+      when 'OK', 'ZERO_RESULTS'
+        @response.parsed_response
+      when 'OVER_QUERY_LIMIT'
+        raise OverQueryLimitError.new(@response)
+      when 'REQUEST_DENIED'
+        raise RequestDeniedError.new(@response)
+      when 'INVALID_REQUEST'
+        raise InvalidRequestError.new(@response)
+      when 'UNKNOWN_ERROR'
+        raise UnknownError.new(@response)
+      when 'NOT_FOUND'
+        raise NotFoundError.new(@response)
+      end
+    
+    end 
+      
+  end
+  
+  
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: google-api-customization
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Abhishek Sharma
@@ -17,6 +17,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/google_api_customization.rb
+- lib/google_api_customization/place.rb
+- lib/google_api_customization/request.rb
 homepage: http://rubygems.org/gems/google_api_customization
 licenses:
 - NONE
@@ -27,17 +29,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.3.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Hello! This is start up for google API customization for Rails