class Badgeville::Client

Attributes

debug[RW]
player_id[RW]
site[RW]
site_id[RW]
timeout[RW]
user[RW]

Public Class Methods

new(email, opts={}) click to toggle source
# File lib/badgeville.rb, line 31
def initialize (email, opts={})
  # Required Parameters
  @site = opts['site']
  @private_key = opts['private_key']
  @public_key = opts['public_key']
  @timeout = opts['timeout'] || TIMEOUT_SECS
  @host = opts['host'] || HOST
  @protocol = opts['protocol'] || PROTOCOL
  @user = email
  @per_page = opts['per_page']
end

Public Instance Methods

award(reward_name) click to toggle source
# File lib/badgeville.rb, line 113
def award reward_name
  reward = reward_definitions.select do |reward|
    reward.name == reward_name
  end.first
  params = {
    'reward[player_id]' => player_id,
    'reward[site_id]' => site_id,
    'reward[definition_id]' => reward.id,
  }
  Reward.new(make_call(:post, :rewards, params))
end
count_activities(opts={}) click to toggle source
# File lib/badgeville.rb, line 86
def count_activities(opts={})
  response = make_call(:get, :activities, opts.merge(:include_totals => true))
  response["paging"]["total_entries"].to_i
end
create_player(opts={}) click to toggle source
# File lib/badgeville.rb, line 43
def create_player(opts={})
  #try to see if player already exists
  begin
    return player_info
  rescue
  end

  #try to create user
  begin
    params = property_params(:user, {email: @user}.merge(opts))
    response = make_call(:post, :users, params)
  rescue BadgevilleError => e
    if e.code != 422
      if ensure_array(e.data["email"]).none? {|erorr_msg|
        error_msg =~ "is already taken"
      }
        raise e
      end
    end
  end

  #create player
  params = {email: @user, site: @site}.merge(
             property_params(:player, {email: @user}.merge(
             opts)))
  json = make_call(:post, :players, params)
  @site_id = json["site_id"]
  @player_id = json["id"]
end
debug=(flag) click to toggle source
# File lib/badgeville.rb, line 138
def debug=(flag)
  log_file = flag ? "stdout" : nil
  RestClient.log = log_file
  @debug = flag
end
delete(reward) click to toggle source
# File lib/badgeville.rb, line 125
def delete reward
  if reward.respond_to?(:earned_at) && reward.earned_at
    end_point = "rewards/#{reward.id}.json"
    begin
      !!session[end_point].delete
    rescue => e
      raise BadgevilleError.new(e.http_code, e.message)
    end
  else
    raise BadgevilleError.new(nil, "can only remove earned rewards. a #{reward.to_json} was given")
  end
end
get_activities(opts={}) click to toggle source
# File lib/badgeville.rb, line 79
def get_activities(opts={})
  response = make_call(:get, :activities, opts)
  response["data"].map do |activity_json|
    Activity.new(activity_json)
  end
end
get_rewards() click to toggle source
# File lib/badgeville.rb, line 101
def get_rewards
  begin
    pages = all_pages_for(:rewards)
    pages.inject([]) do |rewards, page|
      rewards += rewards_from_response(page)
    end
  rescue BadgevilleError => e
    raise e unless e.code == 404
    []
  end
end
log_activity(activity, opts={}) click to toggle source
# File lib/badgeville.rb, line 73
def log_activity(activity, opts={})
  params = property_params(:activity, {verb: activity}.merge(opts))
  response = make_call(:post, :activities, params)
  Activity.new(response)
end
player_info() click to toggle source
# File lib/badgeville.rb, line 144
def player_info
  end_point = "/players/info.json"
  begin
    params = {:email => @user, :site => @site}
    response = session[end_point].get(:params => params)
    data = response.body
    json = JSON.parse(data)
    json = json["data"]
    @site_id = json["site_id"]
    @player_id = json["id"]
  rescue => e
    if e.respond_to? :response && e.response
      data = JSON.parse(e.response)
      raise BadgevilleError.new(e.http_code, data["errors"]["error"])
    else
      raise e
    end
  end
end
reward_definitions() click to toggle source
# File lib/badgeville.rb, line 91
def reward_definitions
  unless @reward_definitions
    pages = all_pages_for(:reward_definitions)
    @reward_definitions = pages.inject([]) do |definitions, page|
      definitions += rewards_from_response(page)
    end
  end
  @reward_definitions
end

Private Instance Methods

add_default_params(method, action, params) click to toggle source
# File lib/badgeville.rb, line 229
def add_default_params(method, action, params)
  should_not_add = params.keys.none? { |k| k =~ /player_id/ }
  should_not_add &= [:users, :players].include? action
  unless should_not_add
    params.merge!(:user => @user, :site => @site)
  end
  if method == :get && @per_page && !params.has_key?(:per_page)
    params[:per_page] = @per_page
  end
  params
end
all_pages_for(action, params={}) click to toggle source
# File lib/badgeville.rb, line 251
def all_pages_for(action, params={})
  pages = []
  current_page = 1
  total_pages = nil
  while total_pages.nil? || current_page <= total_pages
    params[:include_totals] = true unless total_pages
    response  = get_page(action, current_page, params)
    pages << response
    if response["paging"]
      current_page = response["paging"]["current_page"].to_i + 1
      total_pages = response["paging"]["total_pages"].to_i if total_pages.nil?
    else
      total_pages = 0
    end
  end
  pages
end
get_page(action, page, params={}) click to toggle source
# File lib/badgeville.rb, line 247
def get_page(action, page, params={})
  make_call(:get, action, params.merge(page: page))
end
make_call(method, action, params={}) click to toggle source
# File lib/badgeville.rb, line 193
def make_call(method, action, params={})
  end_point = "#{action.to_s}.json"
  params = add_default_params(method, action, params)

  begin
    case method
    when :get
      response = session[end_point].send(method, :params => params)
    when :post, :put, :delete
      response = session[end_point].send(method, to_query(params))
    end
    data = response.body
    json = JSON.parse(data)
  rescue => e
    puts e if debug
    if e.respond_to? :response
      begin
        data = JSON.parse(e.response)
        data.merge!(:params => params,
                    :end_point => end_point,
                    :method => method)
        raise BadgevilleError.new(e.http_code, data)
      rescue TypeError, JSON::ParserError
        msg = "#{e.message} on #{method} #{end_point}: #{params}"
        raise BadgevilleError.new(e.http_code, msg)
      end
    else
      raise e
    end
  end
end
rewards_from_response(response) click to toggle source
# File lib/badgeville.rb, line 241
def rewards_from_response(response)
  response["data"].map do |reward_json|
    Reward.new(reward_json)
  end
end
session() click to toggle source
# File lib/badgeville.rb, line 184
def session
  if @session.nil?
    base_url = "#{@protocol}://#{@host}/api/berlin/#{@private_key}"
    @session = RestClient::Resource.new base_url,
      :timeout => @timeout, :open_timeout => @timeout
  end
  @session
end
to_query(params) click to toggle source
# File lib/badgeville.rb, line 225
def to_query params
  URI.escape(params.map { |k,v| "#{k.to_s}=#{v.to_s}" }.join("&"))
end
valid_response?(obj) click to toggle source
# File lib/badgeville.rb, line 180
def valid_response?(obj)
  obj.is_a?(Array) || obj.is_a?(Hash)
end