rb_facebook 0.0.4

data/lib/rb_facebook.rb

@@ -0,0 +1,335 @@
+module RbFacebook
+
+  VERSION = '0.0.4'
+  class Api
+    
+    attr_accessor :access_token, :app_id, :app_secret
+
+    STATS_METRICS = ["impressions", "clicks", "spent", "social_impressions", "social_clicks", "social_spent", "actions", "unique_impressions", "social_unique_impressions", "unique_clicks", "social_unique_clicks", "connections"]
+
+    def logged_in_user
+      graph_api_parse('me')
+    end
+
+    def ads_accounts
+      rest_api_parse('ads.getAccounts')
+    end
+    
+    def user_accounts
+      graph_api_parse('me/accounts')['data']
+    end
+    
+    def ads_campaigns(args = {})
+      account_id = args[:account_id]
+      params = {'account_id' => account_id}
+      params[:campaign_ids] = "[#{args[:campaign_ids].join(',')}]" if args[:campaign_ids]
+      rest_api_parse('ads.getCampaigns', :params => params, :log_call_url => true)
+    end
+    
+    def insight_metrics(args = {})
+      
+      metrics = args[:metrics]
+      object_id = args[:object_id]
+      start_date = args[:start_date]
+      end_date = args[:end_date]
+      
+      data_calls = []
+      metrics_data = {}
+      
+      metrics.each do |metric|
+        metrics_data[metric] = {}
+        current_date = start_date + 1.day
+        period = 1.day.seconds
+        while current_date <= end_date
+          data_calls << {
+            :fql_query => 
+              "SELECT object_id, metric, end_time, period, value FROM insights 
+              WHERE object_id = #{object_id}
+              AND metric = '#{metric}'
+              AND end_time = end_time_date('#{current_date.strftime("%Y-%m-%d")}')
+              AND period = #{period}",
+            :metric => metric,
+            :date => current_date - 1.day
+          }
+          current_date += 1.day
+        end
+      end
+      
+      data_calls.each_slice(50) do |call_slice|
+        call_slice.map do |call|
+          Thread.new do 
+            #Rails.logger.warn(call)
+            result = rest_api_parse('fql.query', :params => {:query => call[:fql_query]})
+            #Rails.logger.warn(result)
+            Thread.exclusive do
+              begin
+                #Rails.logger.warn "RESULT: #{result.inspect}"
+                metrics_data[call[:metric]][call[:date]] = (result.first || {})['value'] || 0
+              rescue
+                Rails.logger.warn "ERROR THROWN: #{result.inspect}"
+                raise
+              end
+            end
+          end
+        end.each(&:join)
+      end
+      
+      metrics_data
+    end
+    
+    def ads_campaign_stats(args = {})
+      account_id = args[:account_id]
+      campaign_id = args[:campaign_id]
+      include_deleted = args[:include_deleted]
+      start_date = args[:start_date]
+      end_date = args[:end_date]
+      period = args[:interval]
+      
+      data_calls = []
+      metrics_data = {}
+      
+      current_date = start_date
+      
+      while current_date <= end_date
+        metrics_data[current_date] = {}
+        data_calls << {
+          :start_date => current_date.strftime('%s'),
+          :end_date => (current_date + period).strftime('%s'),
+          :date => current_date
+        }
+        current_date += period
+      end
+      
+      data_calls.each_slice(50) do |call_slice|
+        call_slice.map do |call|
+          Thread.new do 
+            date_param = {"time_range" => {"time_start" => call[:start_date], "time_stop" => call[:end_date]}}.to_json
+            result = rest_api_parse('ads.getCampaignStats', :params => {
+              :account_id => account_id,
+              :campaign_ids => "[#{campaign_id}]",
+              :time_ranges => date_param,
+              :include_deleted => include_deleted
+            })
+            Thread.exclusive do
+              #Rails.logger.warn(result.inspect)
+              result.first['stats'].each do |id, stats|
+                stats.each do |metric, value|
+                  next if metric == 'id'
+                  metrics_data[call[:date]][metric] = metrics_data[call[:date]][metric].to_f + value.to_f
+                end
+              end
+            end
+          end
+        end.each(&:join)
+      end
+      
+      metrics_data
+    end    
+      
+    def ad_groups(args = {})
+      params = {:account_id => args[:account_id], :include_deleted => args[:include_deleted] || false}
+      params[:campaign_ids] = args[:campaign_ids] if args[:campaign_ids]
+      params[:campaign_ids] = "[#{args[:campaign_id]}]" if args[:campaign_id]
+      rest_api_parse('ads.getAdGroups', :params => params, :log_call_url => true)
+    end
+    
+    def initialize
+      load_tokens
+    end
+    
+    def load_tokens
+      tokens = YAML.load(File.open(File.join(Rails.root, 'config', 'facebook.yml')))
+      self.app_secret = tokens[:APP_SECRET]
+      self.app_id = tokens[:APP_ID]
+    end    
+    
+    def login_url(current_url, permissions=[:read_insights,:ads_management,:offline_access])
+      "https://www.facebook.com/dialog/oauth?client_id=#{self.app_id}&scope=#{permissions.join(',')}&redirect_uri=#{URI.escape(current_url, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}"
+    end
+    
+    def logout_url(current_url)
+      "https://www.facebook.com/logout.php?next=#{URI.escape(current_url, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}&access_token=#{URI.escape(self.access_token, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}"
+    end
+    
+    def authenticate(args)
+      load_tokens
+      response = graph_api_fetch(
+        "oauth/access_token", 
+        :params => {
+          :client_id => app_id,
+          :client_secret => app_secret,
+          :code => args[:code],
+          :redirect_uri => args[:url]
+        },
+        :no_access_token => true
+      )
+      
+      self.access_token = CGI.parse(response.body)['access_token'].first
+    end
+    
+    def logged_in?
+      check_auth
+      !self.access_token.nil?
+    end
+    
+    def check_auth
+      if self.access_token
+        response = graph_api_fetch('me')
+        if response.code != '200'
+          self.access_token = nil
+        end
+      end
+    end
+    
+    def graph_api_parse(method_name, args = {})
+      ActiveSupport::JSON.decode(graph_api_fetch(method_name, args).body)
+    end
+      
+    def graph_api_fetch(method_name, args = {})
+      api_params = args[:params] || {}
+      use_access_token = !args[:no_access_token]
+      log_call_url = args[:log_call_url]
+      
+      api_fetch('graph.facebook.com', method_name, api_params, use_access_token, log_call_url)
+    end
+    
+    def rest_api_parse(method_name, args = {})
+      results = []
+      result = [:dummy]
+      previous_result = []
+      
+      page = 0
+      per_page = 10
+      
+      until result.empty? or result.is_a?(Hash) or result == previous_result
+        if method_name =~ /^ads./
+          args[:params] = {} unless args[:params]
+          args[:params][:limit] = per_page 
+          args[:params][:offset] = per_page * page
+          #args[:params][:include_count] = 1
+        end
+        
+        previous_result = result
+        result = ActiveSupport::JSON.decode(rest_api_fetch(method_name, args).body)
+        
+        page += 1
+        results << result unless result == previous_result
+        
+        result = [] unless method_name =~ /^ads\./
+      end
+      results.flatten
+    end
+    
+    def rest_api_fetch(method_name, args = {})
+      api_params = args[:params] || {}
+      use_access_token = !args[:no_access_token]
+      log_call_url = args[:log_call_url]
+      multipart_post = args[:mp_post]
+      
+      api_params["format"] = 'json-strings'
+
+      api_fetch('api.facebook.com/method', method_name, api_params, use_access_token, log_call_url, :mp_post => multipart_post)
+      
+    end
+    
+    def api_fetch(api_base_url, method_name, api_params, use_access_token, log_call_url, args = {})
+      
+      api_params["access_token"] = self.access_token if use_access_token
+      
+      params_fragment = api_params.map{|k,v|"#{k}=#{URI.escape("#{v}", Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}"}.join('&')
+      
+      call_url = ['https:/', api_base_url, method_name].join('/')
+      call_url << "?#{params_fragment}" unless params_fragment.blank? or args[:mp_post]
+      
+      Rails.logger.warn("About to fetch: #{call_url}") if log_call_url
+      Rails.logger.warn("Parameters: #{api_params.inspect}") if log_call_url
+      
+      uri = URI.parse(call_url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      if args[:mp_post]
+        mp_post = args[:mp_post]
+        api_params[mp_post[:name]] = UploadIO.new(mp_post[:file], mp_post[:mime], mp_post[:name])
+        post = Net::HTTP::Post::Multipart.new(
+          uri.request_uri,
+          api_params
+        )
+        response = http.request(post)
+      else
+        response = http.request(Net::HTTP::Get.new(uri.request_uri))
+      end
+      
+      Rails.logger.warn("And returned #{response.inspect}: #{response.body}") if log_call_url
+      
+      response
+    end
+    
+    def self.format_targeting(targeting)
+      Rails.logger.warn '-0-0-0-0-0-0-0-0-0-0-'
+      Rails.logger.warn 'ABOUT TO FORMAT TARGETING'
+      Rails.logger.warn targeting.inspect
+      Rails.logger.warn '-0-0-0-0-0-0-0-0-0-0-'
+      
+      begin
+        
+        formatted_targeting = []
+        targeting = targeting.dup
+        Rails.logger.warn(targeting.inspect)
+        adgroup_id = targeting.delete('adgroup_id')
+        
+        genders = targeting.delete('genders')
+        if genders.nil? or genders.length == 2
+          gender = 'People'
+        elsif genders == ['1']
+          gender = 'Men'
+        else
+          gender = 'Women'
+        end
+        
+        #education_statuses =
+        
+        age_min = targeting.delete('age_min')
+        age_max = targeting.delete('age_max')
+        if age_min and age_max
+          formatted_targeting << "#{gender} between #{age_min} and #{age_max} years of age"
+        elsif age_min
+          formatted_targeting << "#{gender} #{age_min} years of age and older"
+        elsif age_max
+          formatted_targeting << "#{gender} #{age_max} years of age and younger"
+        elsif gender != 'People'
+          formatted_targeting << "#{gender} only"
+        end
+        
+        relationship_statuses = targeting.delete('relationship_statuses')
+        if relationship_statuses and !relationship_statuses.include?('0') #0 indicates ALL
+          ref = {'1' => 'single', '2' => 'in a relationship', '3' => 'married', '4' => 'engaged'}
+          formatted_targeting << "Are #{relationship_statuses.map{|s|ref[s]}.join(' or ')}"
+        end
+
+        education_statuses = targeting.delete('education_statuses')
+        if education_statuses and !education_statuses.include?('0') #0 indicates ALL
+          ref = {'1' => 'in high school', '2' => 'in college', '3' => 'college graduates'}
+          formatted_targeting << "Are #{education_statuses.map{|s|ref[s]}.join(' or ')}"
+        end
+
+        #puts "remaining keys: #{targeting.keys.inspect}"
+        targeting.each do |target_name, target_data|
+          target_string = "#{target_name}: "
+          target_data = target_data.map{|t|t['name']} if target_data.first.is_a?(Hash)
+          target_string << [target_data].flatten.join(', ')
+          formatted_targeting << target_string
+        end
+        
+        return formatted_targeting
+      rescue => ex
+        
+        Rails.logger.warn "ERROR FORMATTING TARGETING"
+        Rails.logger.warn ex.backtrace
+        return ["There was an error formatting the following raw targeting", targeting.inspect]
+      end
+      
+    end  
+    
+  end
+
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: rb_facebook
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Joshua Levinson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-28 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+description: |
+  Provides a simple way to access all methods of the facebook REST and Graph APIs.
+  
+  (c)2011 Raybeam, Inc. (www.raybeam.com)
+
+email: 
+- pianojosh@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/rb_facebook.rb
+has_rdoc: true
+homepage: http://www.raybeam.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rb_facebook
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Lightweight wrapper around the facebook REST and Graph API
+test_files: []
+