fourmer 1.0.0

data/lib/foursquare/errors.rb

@@ -0,0 +1,24 @@
+module Foursquare
+  module Merchant
+    module Errors
+      class APIError < StandardError; end
+      class OAuthError < APIError; end
+
+      # Dynamically create errors from responses we receive from the
+      # Foursquare Merchant API
+      def self.new(type, message=nil)
+        unless self.const_defined?(type)
+          self.const_set type.intern, Class.new(APIError) do
+            attr_reader :message
+
+            def initialize(message=nil)
+              @message = message
+            end
+          end
+        end
+
+        self.const_get(type).new(message)
+      end
+    end
+  end
+end

data/lib/foursquare/model.rb

@@ -0,0 +1,32 @@
+module Foursquare
+  module Merchant
+
+    class Model < Hashie::Trash
+      include HTTParty
+      include Merchant::Requests
+
+      base_uri Merchant::Requests::API
+      format :json
+
+      attr_reader :consumer
+      def initialize(hash, consumer)
+        @consumer = consumer
+        super(hash)
+      end
+
+      private
+        def listify(venues)
+          case venues
+          when Array
+            venues.join(',')
+          when String
+            venues
+          else
+            raise ArgumentError, "Please ensure you're attempting to use either an " +
+                                 "array of venue ids, or a comma delimited list of ids"
+          end
+        end
+
+    end
+  end
+end

data/lib/foursquare/requests.rb

@@ -0,0 +1,49 @@
+module Foursquare
+  module Merchant
+
+    module Requests
+      API = 'https://api.foursquare.com/v2'
+      OAUTH = 'https://foursquare.com/oauth2'
+
+      def get(path, params)
+        request = self.class.get(path, {:query => camelize(params).merge(auth_params)})
+        handle_response(request)
+      end
+
+      def post(path, params)
+        request = self.class.post(path, {:body => camelize(params).merge(auth_params)})
+        handle_response(request)
+      end
+
+      private
+        def camel_case(string, capital=true)
+          elem = capital == true ? string.capitalize : string
+          elem.gsub(/(_[a-z])/) { |match| match[1..1].upcase }
+        end
+
+        def camelize(params)
+          params.inject({}) { |o, (k, v)| o[camel_case(k.to_s, false)] = v; o}
+        end
+
+        def auth_params
+          if @consumer.oauth_token
+            {:oauth_token => @consumer.oauth_token }
+          else
+            {:client_id => @consumer.client_id, :client_secret => @consumer.client_secret }
+          end
+        end
+
+        def handle_response(request)
+          response = request.parsed_response
+          meta = response['meta']
+
+          if meta['code'] != 200
+            type, message = camel_case(meta['errorType']), meta['errorDetail']
+            raise Merchant::Errors.new(type, message)
+          end
+
+          response['response']
+        end
+    end
+  end
+end

data/lib/foursquare/special.rb

@@ -0,0 +1,39 @@
+module Foursquare
+  module Merchant
+
+    class Special < Model
+      property :count1
+      property :count2
+      property :count3
+      property :description
+      property :detail
+      property :fine_print,           :from => :finePrint
+      property :friends_here,         :from => :friendsHere
+      property :icon
+      property :id
+      property :interaction
+      property :message
+      property :name
+      property :progress
+      property :progress_description, :from => :progressDescription
+      property :provider
+      property :redemption
+      property :state
+      property :status
+      property :target
+      property :text
+      property :title
+      property :type
+      property :unlocked
+
+      def retire
+        self.post("/specials/#{id}/retire", {})
+      end
+
+      def configuration
+        self.class.new(self.get("/specials/#{id}/configuration", {})['special'], @consumer)
+      end
+    end
+
+  end
+end

data/lib/foursquare/specials.rb

@@ -0,0 +1,33 @@
+module Foursquare
+  module Merchant
+
+    class Specials < Base
+      base_uri "#{API}/specials"
+
+      def find(special_id, params={})
+        response = self.get("/#{special_id}", params)
+        Foursquare::Merchant::Special.new(response['special'], @consumer)
+      end
+
+      def add(params)
+        response = self.post("/add", params)
+        Foursquare::Merchant::Special.new(response['special'], @consumer)
+      end
+      
+      def list(params={})
+        response = self.get("/list", params)
+        specials = response['specials']['items']
+        specials.map { |item| Foursquare::Merchant::Special.new(item, @consumer) }
+      end
+
+      def search(params)
+        raise "Must include lat/lng string" unless params.has_key? :ll
+        response = self.get("/search", params)
+        specials = response['specials']['items']
+        specials.map { |item| Foursquare::Merchant::Special.new(item, @consumer) }
+      end
+
+    end
+
+  end
+end

data/lib/foursquare/timeseries.rb

@@ -0,0 +1,13 @@
+module Foursquare
+  module Merchant
+
+    class TimeSeries < Hashie::Trash
+      property :venue_id,         :from => :venueId,        :required => true
+      property :total_checkins,   :from => :totalCheckins
+      property :new_checkins,     :from => :newCheckins
+      property :viewing_users,    :from => :viewingUsers
+      property :unlocking_users,  :from => :unlockingUsers
+    end
+
+  end
+end

data/lib/foursquare/venue.rb

@@ -0,0 +1,52 @@
+module Foursquare
+  module Merchant
+
+    class Venue < Model
+      property :been_here,      :from => :beenHere
+      property :canonical_url,  :from => :canonicalUrl
+      property :categories
+      property :contact
+      property :created_at,     :from => :createdAt
+      property :description
+      property :here_now,       :from => :hereNow
+      property :id
+      property :listed
+      property :location
+      property :mayor
+      property :name
+      property :photos
+      property :short_url,      :from => :shortUrl
+      property :specials
+      property :stats
+      property :tags
+      property :time_zone,      :from => :timeZone
+      property :tips
+      property :todos
+      property :url
+      property :verified
+
+      def fetch
+        response = self.get("/venues/#{id}", {})['venue']
+        self.class.new(response, @consumer)
+      end
+
+      def stats(start_at=nil, end_at=nil)
+        params = {}
+        params[:start_at] = start_at if start_at
+        params[:end_at]   = end_at if end_at
+
+        response = self.get("/venues/#{id}/stats", params)['stats']
+        VenueStats.new(response)
+      end
+
+      def edit(params)
+        response = self.post("/venues/#{id}/edit", params)['venue']
+        temp_venue = self.fetch
+        temp_venue.keys.each { |k| self.send("#{k}=", temp_venue.send("#{k}")) }
+        self
+      end
+
+    end
+
+  end
+end

data/lib/foursquare/venue_group.rb

@@ -0,0 +1,31 @@
+module Foursquare
+  module Merchant
+
+    class VenueGroup < Model
+      property :id
+      property :name
+      property :venues
+
+      def initialize(hash, consumer)
+        super
+        self.venues = self.venues['items'].map { |item| Venue.new(item, @consumer) } if self.venues
+      end
+
+      def delete
+        self.post("venuegroups/#{id}/delete", {})
+      end
+
+      def add_venue(venue_ids)
+        params = {:venue_ids => listify(venue_ids)}
+        self.post("venuegroups/#{id}/addvenue", params)
+      end
+
+      def remove_venue(venue_ids)
+        params = {:venue_ids => listify(venue_ids)}
+        self.post("venuegroups/#{id}/removevenue", params)
+      end
+
+    end
+
+  end
+end

data/lib/foursquare/venue_groups.rb

@@ -0,0 +1,26 @@
+module Foursquare
+  module Merchant
+
+    class VenueGroups < Base
+      base_uri "#{API}/venuegroups"
+
+      def find(venue_group_id, params={})
+        response = self.get("/#{venue_group_id}", params)
+        Foursquare::Merchant::VenueGroup.new(response['venueGroup'], @consumer)
+      end
+
+      def add(params)
+        response = self.post("/add", params)
+        Foursquare::Merchant::VenueGroup.new(response['venueGroup'], @consumer)
+      end
+      
+      def list(params={})
+        response = self.get("/list", params)
+        venue_groups = response['venueGroups']['items']
+        venue_groups.map { |item| Foursquare::Merchant::VenueGroup.new(item, @consumer) }
+      end
+
+    end
+
+  end
+end

data/lib/foursquare/venue_stats.rb

@@ -0,0 +1,19 @@
+module Foursquare
+  module Merchant
+
+    class VenueStats < Hashie::Trash
+      property :sharing
+      property :total_checkins,         :from => :totalCheckins
+      property :new_checkins,           :from => :newCheckins
+      property :unique_visitors,        :from => :uniqueVisitors
+      property :gender_breakdown,       :from => :genderBreakdown
+      property :age_breakdown,          :from => :ageBreakdown
+      property :hour_breakdown,         :from => :hourBreakdown
+      property :visit_count_histogram,  :from => :visitCountHistogram
+      property :top_visitors,           :from => :topVisitors
+      property :recent_visitors,        :from => :recentVisitors
+    end
+
+
+  end
+end

data/lib/foursquare/venues.rb

@@ -0,0 +1,38 @@
+module Foursquare
+  module Merchant
+
+    class Venues < Base
+      base_uri "#{API}/venues"
+
+      def find(venue_id, params={})
+        response = self.get("/#{venue_id}", params)
+        Foursquare::Merchant::Venue.new(response['venue'], @consumer)
+      end
+
+      def managed(params={})
+        response = self.get("/managed", params)
+        venues = response['venues']
+        venues.map { |item| Foursquare::Merchant::Venue.new(item, @consumer) }
+      end
+
+      def timeseries(venue_ids, start_at=nil, end_at=nil)
+        params = {}
+        params[:venue_id] = listify(venue_ids)
+        params[:start_at] = start_at if start_at
+        params[:end_at]   = end_at if end_at
+
+        response = self.get("/timeseries", params)['timeseries']
+        response.map { |ts| TimeSeries.new(ts) }
+      end
+
+      def search(params)
+        raise "Must include lat/lng string" unless params.has_key? :ll
+        response = self.get("/search", params)
+        venues = response['groups'].map { |res| res['items'] }.flatten
+        venues.map { |item| Foursquare::Merchant::Venue.new(item, @consumer) }
+      end
+
+    end
+
+  end
+end

data/test/helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'mocha'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'fourmer'
+
+class Test::Unit::TestCase
+end

data/test/test_base.rb

@@ -0,0 +1,62 @@
+require File.expand_path('../helper', __FILE__)
+
+module Foursquare
+  module Merchant
+    module Errors
+      class TestError < APIError; end
+    end
+  end
+end
+
+class TestBase < Test::Unit::TestCase
+  def setup
+    @consumer = Foursquare::Merchant::Consumer.new('ACCESS_TOKEN')
+    @base = Foursquare::Merchant::Base.new(@consumer)
+  end
+
+  def test_api_path
+    assert_equal('https://api.foursquare.com/v2', Foursquare::Merchant::Base::API)
+  end
+
+  def test_initialize_with_consumer
+    Foursquare::Merchant::Base.expects(:new).with(@consumer).returns(Foursquare::Merchant::Base)
+    Foursquare::Merchant::Base.new(@consumer)
+  end
+
+  def test_get_success
+    response = {'meta' => {'code' => 200}, 'response' => true}
+    Foursquare::Merchant::Base.stubs(:get).returns(stub(:parsed_response => response))
+    assert @base.get('/', {})
+  end
+
+  def test_post_success
+    response = {'meta' => {'code' => 200}, 'response' => true}
+    Foursquare::Merchant::Base.stubs(:post).returns(stub(:parsed_response => response))
+    assert @base.post('/', {})
+  end
+
+  def test_get_failure
+    response = {
+      'meta' => {
+        'code' => 400,
+        'errorType' => 'test_error',
+        'errorDetail' => 'This is a test error'
+      }
+    }
+    Foursquare::Merchant::Base.stubs(:get).returns(stub(:parsed_response => response))
+    assert_raise(Foursquare::Merchant::Errors::TestError) { @base.get('/', {}) }
+  end
+
+  def test_post_failure
+    response = {
+      'meta' => {
+        'code' => 400,
+        'errorType' => 'test_error',
+        'errorDetail' => 'This is a test error'
+      }
+    }
+    Foursquare::Merchant::Base.stubs(:post).returns(stub(:parsed_response => response))
+    assert_raise(Foursquare::Merchant::Errors::TestError) { @base.post('/', {}) }
+  end
+
+end