rlocu2 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 26de612b01f871cc85fdc050a23abd9153182944
+  data.tar.gz: 36afb4e8bf6a279880ab9247e5d67137a4c2284c
+SHA512:
+  metadata.gz: 5b99139807aa68f7814164fea04bf287428be649e40e14e84c38e0a127c97b9903949fc7af720030de088dfe62dc7fdd0670ffdfea5ea3feabb303898b3830e2
+  data.tar.gz: 4ae868af86ea6631e940295883c413065b423eee0d38533edd57f953dcc0f0a859265e9068df391670e175a55a5488957835f343241278046cf87360259c284f

data/.gitignore

@@ -0,0 +1,2 @@
+.idea/*
+rlocu2-*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rlocu.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    rlocu2 (0.1.0)
+      faraday (~> 0.9.2)
+      faraday_middleware (~> 0.10.0)
+      json (~> 1.8, >= 1.8.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    faraday (0.9.2)
+      multipart-post (>= 1.2, < 3)
+    faraday_middleware (0.10.0)
+      faraday (>= 0.7.4, < 0.10)
+    json (1.8.3)
+    multipart-post (2.0.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.2)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rlocu2!
+  rspec (~> 3.4, >= 3.4.0)
+
+BUNDLED WITH
+   1.11.2

data/README.md

@@ -0,0 +1,50 @@
+# Rlocu2
+
+Unoffical, and currently incomplete wrapper for the Locu API 2.0 (locu.com)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rlocu2'
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself:
+
+    $ gem install rlocu2
+
+## Usage
+
+First initialize the client with YOUR API KEY:
+
+    $ require 'rlocu2'
+    $
+    $ client = Rlocu2::Client.new(:api_key => YOUR_API_KEY)
+
+Prepare Hash with params to send to Locu:
+
+    $ params = Hash.new
+    $ params['fields'] = ['name','location','contact']
+    $ params['venue_queries'] = []
+    $ params['venue_queries'] << { 'name' => 'bistro central parc' }
+
+Make call:
+
+    $ client.venues_search(params)
+
+Response is a Rlocu2::Venue object
+
+## Test - RSpec
+
+If you want to donwload the repository and test-it remember to change the API KEY inside 'spec/configuration.rb'
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-checkout`)
+3. Commit your changes (`git commit -am 'Add features'`)
+4. Push to the branch (`git push origin my-checkout`)
+5. Create new Pull Request

data/lib/rlocu2/client/venues.rb

@@ -0,0 +1,55 @@
+module Rlocu2
+
+  module Venues
+
+    FIELDS = ['locu_id',
+              'name',
+              'short_name',
+              'description',
+              'website_url',
+              'menu_url',
+              'menu_items',
+              'menus',
+              'open_hours',
+              'external',
+              'redirected_from',
+              'categories',
+              'location',
+              'contact',
+              'locu', # pro account
+              'delivery',
+              'extended',
+              'media' # pro account
+    ].freeze
+
+    def venues_search(params={})
+      options={}
+      options['api_key'] = @api_key if @api_key
+      options['fields'] = Array.new
+      if (params.has_key? 'fields') && params['fields'].is_a?(Array)
+        params['fields'].each do |p|
+          options['fields'] << p if FIELDS.include? p
+        end
+      end
+
+      if (params.has_key? 'venue_queries') && params['venue_queries'].is_a?(Array)
+        # TODO check possible venue_queries
+        options['venue_queries'] = params['venue_queries']
+      end
+
+      if (params.has_key? 'menu_item_queries') && params['menu_item_queries'].is_a?(Array)
+        # TODO check possible menu_item_queries
+        options['menu_item_queries'] = params['menu_item_queries']
+      end
+
+      response = connection.post do |req|
+        req.url "venue/search"
+        req.body = options.to_json
+      end
+
+     return_error_or_body(response, response.body,'venues')
+
+    end
+  end
+
+end

data/lib/rlocu2/client.rb

@@ -0,0 +1,83 @@
+module Rlocu2
+  # Wrapper for the Locu API v 2.0
+  #
+  class Client
+    attr_reader :api_key
+
+    DEFAULT_CONNECTION_MIDDLEWARE = [
+        Faraday::Request::UrlEncoded,
+        FaradayMiddleware::ParseJson
+    ]
+
+
+    def initialize(options={})
+      @api_key = options[:api_key] || Rlocu2.api_key
+      @connection_middleware = options[:connection_middleware] || Rlocu2.connection_middleware || []
+      @connection_middleware += DEFAULT_CONNECTION_MIDDLEWARE
+    end
+
+    def connection
+      @connection ||= Faraday::Connection.new(:url => api_url, :headers => default_headers) do |builder|
+        @connection_middleware.each do |middleware|
+          builder.use *middleware
+        end
+        builder.adapter Faraday.default_adapter
+      end
+    end
+
+    def api_url
+      'https://api.locu.com/v2/'
+    end
+
+    def return_error_or_body(response, response_body, type)
+      if response.status == 200
+        # REMAP & PARSE Objects
+        output = Hash.new
+        output['status'] = response_body['status']
+        output['http_status'] = response_body['http_status']
+        if type == 'venues'
+          output['venues'] = response_body['venues'].each.reduce([]) { |accum, venue| accum << Rlocu2::Venue.new(venue) }
+        end
+        output
+      else
+        raise Rlocu2::APIError.new(response.body)
+      end
+    end
+
+
+    include Venues
+
+    private
+
+    def default_headers
+      headers = {
+          :accept =>  'application/json',
+          :user_agent => 'Rlocu2 Ruby Gem'
+      }
+    end
+
+  end
+
+
+
+
+  class APIError < StandardError
+
+    attr_reader :code
+    attr_reader :status
+    attr_reader :detail
+
+    def initialize(response)
+      @code     = response['http_status']
+      @status   = response['errorType']
+      @detail   = response['error']
+    end
+
+    def message
+      "#{@status}: #{@detail} (#{@code})"
+    end
+    alias :to_s :message
+  end
+
+
+end

data/lib/rlocu2/objects.rb

@@ -0,0 +1,231 @@
+module Rlocu2
+
+  class Venue
+    attr_accessor :locu_id, :name, :short_name, :description, :website_url, :menu_url, :menus, :menu_items, :open_hours, :external,
+                  :redirected_from, :categories, :location, :contact, :locu, :delivery, :extended, :media
+
+    def initialize(venue)
+      build_from_hash(venue)
+    end
+
+    def build_from_hash(venue)
+      venue.each { |k,v| self.send("#{k.to_s}=", v) }
+    end
+
+    # BUILD sub structures
+
+    def external=(externals_list)
+      @external = []
+      externals_list.each { |external_id| @external << Rlocu2::ExternalID.new(id: external_id['id'], url: external_id['url'], mobile_url: external_id['mobile_url'])}
+    end
+
+    def categories=(categories_list)
+      @categories = []
+      categories_list.each do |category|
+        c = Rlocu2::Category.new
+        category.each { |k,v| c.send("#{k.to_s}=", v) }
+        @categories << c
+      end
+    end
+
+    def location=(location)
+      l = Rlocu2::Location.new
+      location.each { |k,v| l.send("#{k.to_s}=", v) }
+      @location = l
+    end
+
+    def contact=(contact)
+      c = Rlocu2::Contact.new
+      contact.each { |k,v| c.send("#{k.to_s}=", v) }
+      @location = c
+    end
+
+    def locu=(locu)
+      lc = Rlocu2::Locu.new
+      locu.each { |k,v| lc.send("#{k.to_s}=", v) }
+      @locu = lc
+    end
+
+    def delivery=(delivery)
+      d = Rlocu2::Delivery.new
+      delivery.each { |k,v| d.send("#{k.to_s}=", v) }
+      @location = l
+    end
+
+    def extended=(extended)
+      e = Rlocu2::Extended.new
+      extended.each { |k,v| e.send("#{k.to_s}=", v) }
+      @extended = e
+    end
+
+    def media=(media)
+      m = Rlocu2::Media.new
+      media.each { |k,v| m.send("#{k.to_s}=", v) }
+      @media = m
+    end
+
+    def menus=(menu_list)
+      @menus = []
+      menu_list.each do |menu|
+        @menus << Menu.new(menu)
+      end
+    end
+
+  end
+
+  class  ExternalID
+    attr_accessor :id, :url, :mobile_url
+  end
+
+  class Category
+    attr_accessor :name, :str_id
+  end
+
+  class Location
+    attr_accessor :address1, :address2, :address3, :locality, :region, :postal_code, :country, :geo
+  end
+
+  class Contact
+    attr_accessor :phone, :fax, :email, :phones, :faxes, :emails, :business_owner
+  end
+
+  class Locu
+    attr_accessor :owner_controlled, :verification_level, :last_updated_by_owner, :last_updated_by_locu, :last_updated_listings, :last_updated_menu, :last_modified, :added_to_locu
+  end
+
+  class Delivery
+    attr_accessor :will_deliver, :hours, :minimum_order, :areas
+  end
+
+  class Extended
+    attr_accessor :established_date, :closed_date, :closed_permanently, :payment_methods, :cash_only, :history, :alcohol, :parking, :wifi , :corkage, :dietary_restrictions,
+                  :music, :sports , :wheelchair_accessible, :reservations, :outdoor_seating, :good_for_kids, :good_for_groups, :meals, :takeout, :smoking, :noise_level,
+                  :minimum_age, :specialties, :attire, :waiter_service, :television, :caters, :ambience, :price_range, :currency
+  end
+
+  class Media
+    attr_accessor :cover_photo, :venue_photos, :menu_photos, :logos, :videos
+  end
+
+
+  # class copied from old locu gem ( https://github.com/swelltrain/rlocu/blob/master/lib/rlocu/menu.rb )
+
+  class Menu
+    attr_accessor :menu_name, :sections
+
+    def initialize(menu_hash)
+      @menu_name = menu_hash['menu_name']
+      self.sections = menu_hash['sections']
+    end
+
+    def sections=(sections_list)
+      @sections = []
+      sections_list.each { |section| @sections << Rlocu2::Menu::Section.new(section) } unless sections_list.nil?
+    end
+
+    class Section
+      attr_accessor :section_name, :subsections
+      def initialize(section_hash)
+        @section_name = section_hash['section_name']
+        self.subsections = section_hash['subsections']
+      end
+
+      def subsections=(subsections_list)
+        @subsections = []
+        subsections_list.each { |subsection| @subsections << Rlocu2::Menu::Subsection.new(subsection) } unless subsections_list.nil?
+      end
+    end
+
+    class Subsection
+      attr_accessor :subsection_name, :contents
+      def initialize(subsection_hash)
+        @subsection_name = subsection_hash['subsection_name']
+        self.contents = subsection_hash['contents']
+      end
+
+      def contents=(contents_list)
+        @contents = []
+        return if contents_list.nil?
+        contents_list.each do |content|
+          @contents << case content['type']
+                         when 'SECTION_TEXT'
+                           Rlocu2::Menu::SectionText.new(content)
+                         when 'ITEM'
+                           Rlocu2::Menu::MenuItem.new(content)
+                         else
+                           raise "Menu Content type not found #{content['type']}"
+                       end
+        end
+      end
+    end
+
+    class SectionText
+      attr_accessor :type, :text
+      def initialize(section_text_hash)
+        @type = section_text_hash['type']
+        @text = section_text_hash['text']
+      end
+
+      def to_s
+        @text
+      end
+    end
+
+    class Item
+      attr_accessor :type, :name, :description, :price, :option_groups
+      def initialize(item_hash)
+        @type = item_hash['type']
+        @name = item_hash['name']
+        @description = item_hash['description']
+        @price = item_hash['price']
+        self.option_groups = item_hash['option_groups']
+      end
+
+      def option_groups=(option_groups_list)
+        @option_groups = []
+        return if option_groups_list.nil?
+        option_groups_list.each { |option_group| @option_groups << Rlocu2::Menu::OptionGroup.new(option_group) }
+      end
+    end
+
+    class MenuItem < Rlocu2::Menu::Item
+      attr_accessor :menu_name, :section_name, :subsection_name, :section_text, :type, :currency_symbol, :photos
+      def initialize(menu_item_hash)
+        @menu_name = menu_item_hash['menu_name']
+        @section_name = menu_item_hash['section_name']
+        @subsection_name = menu_item_hash['subsection_name']
+        @section_text = menu_item_hash['section_text']
+        @currency_symbol = menu_item_hash['currency_symbol']
+        @photos = menu_item_hash['photos']
+        super
+      end
+    end
+
+    class OptionGroup
+      attr_accessor :options, :type, :text
+      def initialize(option_group_hash)
+        @type = option_group_hash['type']
+        @text = option_group_hash['text']
+        self.options = option_group_hash['options']
+      end
+
+      def options=(options_list)
+        @options = []
+        options_list.each { |option| @options << Rlocu2::Menu::Option.new(option) } unless options_list.nil?
+      end
+    end
+
+    class Option
+      attr_accessor :name, :price
+      def initialize(option_hash)
+        @name = option_hash['name']
+        @price = option_hash['price']
+      end
+
+      def to_s
+        "#{name} #{price}"
+      end
+    end
+
+  end
+end

data/lib/rlocu2.rb

@@ -0,0 +1,24 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'json'
+
+directory = File.expand_path(File.dirname(__FILE__))
+
+module Rlocu2
+  class << self
+
+    FIELDS = [:api_key,
+              :connection_middleware]
+    attr_accessor(*FIELDS)
+
+    def configure
+      yield self
+      true
+    end
+
+  end
+
+  require 'rlocu2/client/venues'
+  require 'rlocu2/client'
+  require 'rlocu2/objects'
+end

data/rlocu2.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+
+  s.name        = 'rlocu2'
+  s.version     = '0.1.0'
+  s.date        = '2016-02-12'
+  s.summary     = "A ruby wrapper for Locu API 2.0"
+  s.description = "The Locu API gives you access to real-time local business data, from opening hours to price lists, such as restaurant menus"
+  s.authors     = ["Andrea Cadamuro"]
+  s.homepage    = 'https://github.com/caimano/rlocu2'
+  s.license     = 'MIT'
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {spec}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency('faraday', '~> 0.9.2') # 08.02.2016
+  s.add_runtime_dependency('faraday_middleware', '~> 0.10.0') # 09.02.2016
+  s.add_runtime_dependency('json', '~> 1.8', '>= 1.8.3') # 09.02.2016
+
+  s.add_development_dependency('rspec', '~> 3.4', '>= 3.4.0')  # 05.02.2016
+
+end

data/spec/configuration.rb

@@ -0,0 +1 @@
+API_KEY = '3760eae936ff2505c23984e3743f0a868a15128e'

data/spec/rlocu2_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Rlocu2 do
+  let(:client) do
+    client = Rlocu2::Client.new(:api_key => API_KEY)
+  end
+
+  context 'Rlocu2' do
+    it 'client should be a Rlocu2::Client' do
+      expect(client).to be_an_instance_of(Rlocu2::Client)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'bundler/setup'
+require 'configuration'
+
+Bundler.setup
+
+require 'rlocu2'
+
+RSpec.configure do |config|
+
+end

data/spec/venues_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+describe Rlocu2 do
+  let(:client) do
+    client = Rlocu2::Client.new(:api_key => API_KEY)
+  end
+
+  context 'Venues' do
+
+    it 'Querying for venues by name' do
+
+      params = Hash.new
+      params['fields'] = ['name','location','contact']
+      params['venue_queries'] = []
+      params['venue_queries'] << { 'name' => 'bistro central parc' }
+      response = client.venues_search(params)
+
+      expect(response['status']).to eq('success')
+      expect(response['http_status']).to eq(200)
+      expect(response['venues']).to be_an_instance_of(Array)
+      response['venues'].each do |v|
+        expect(v).to be_an_instance_of(Rlocu2::Venue)
+      end
+
+    end
+
+    it 'Querying for venues in a circular area' do
+
+      params = Hash.new
+      params['fields'] = ['name','location','contact']
+      params['venue_queries'] = []
+      params['venue_queries'] << { 'location' => { 'geo' => {'$in_lat_lng_radius' => [37.7750, -122.4183, 5000] } } }
+      response = client.venues_search(params)
+
+      expect(response['status']).to eq('success')
+      expect(response['http_status']).to eq(200)
+      expect(response['venues']).to be_an_instance_of(Array)
+
+      response['venues'].each do |v|
+        expect(v).to be_an_instance_of(Rlocu2::Venue)
+      end
+    end
+
+    it 'Querying for presence or absence of fields' do
+
+      params = Hash.new
+      params['fields'] = ['name','location','contact']
+      params['venue_queries'] = []
+      params['venue_queries'] << {'menus' => {'$present' => true}}
+      response = client.venues_search(params)
+
+      expect(response['status']).to eq('success')
+      expect(response['http_status']).to eq(200)
+      expect(response['venues']).to be_an_instance_of(Array)
+
+      response['venues'].each do |v|
+        expect(v).to be_an_instance_of(Rlocu2::Venue)
+      end
+    end
+
+    it 'Querying for venues open during certain hours' do
+
+      params = Hash.new
+      params['fields'] = ['name','location','contact']
+      params['venue_queries'] = []
+      params['venue_queries'] << { 'open_hours' => { 'monday' => ['18:00', '20:00']} }
+      response = client.venues_search(params)
+
+      expect(response['status']).to eq('success')
+      expect(response['http_status']).to eq(200)
+      expect(response['venues']).to be_an_instance_of(Array)
+
+      response['venues'].each do |v|
+        expect(v).to be_an_instance_of(Rlocu2::Venue)
+      end
+    end
+=begin
+     # ?!? The "menu_items" key is not supported. (400)
+     it 'Querying for all restaurants in Boston that serve pizza' do
+
+      params = Hash.new
+      params['fields'] = ['name']
+      params['venue_queries'] = []
+      params['venue_queries'] << { 'location' => { 'locality' => 'Boston'} }
+      params['menu_item_queries'] = []
+      params['menu_item_queries'] << { 'name' => 'pizza' }
+      response = client.venues_search(params)
+
+      expect(response['status']).to eq('success')
+      expect(response['http_status']).to eq(200)
+      expect(response['venues']).to be_an_instance_of(Array)
+
+    end
+=end
+    it 'Querying for many attributes' do
+
+      params = Hash.new
+      params['fields'] = ['locu_id','name','description','website_url','location','categories','menus','open_hours','extended','description','short_name']
+      params['venue_queries'] = []
+      params['venue_queries'] << { 'name' => 'bistro central parc', 'menus' => {'$present' => true} }
+      response = client.venues_search(params)
+
+      expect(response['status']).to eq('success')
+      expect(response['http_status']).to eq(200)
+      expect(response['venues']).to be_an_instance_of(Array)
+
+      response['venues'].each do |v|
+        expect(v).to be_an_instance_of(Rlocu2::Venue)
+      end
+    end
+
+
+  end
+
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: rlocu2
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrea Cadamuro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+description: The Locu API gives you access to real-time local business data, from
+  opening hours to price lists, such as restaurant menus
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- README.md
+- lib/rlocu2.rb
+- lib/rlocu2/client.rb
+- lib/rlocu2/client/venues.rb
+- lib/rlocu2/objects.rb
+- rlocu2.gemspec
+- spec/configuration.rb
+- spec/rlocu2_spec.rb
+- spec/spec_helper.rb
+- spec/venues_spec.rb
+homepage: https://github.com/caimano/rlocu2
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.4.8
+signing_key: 
+specification_version: 4
+summary: A ruby wrapper for Locu API 2.0
+test_files: []