gs_graph 2.6.5

data/lib/gs_graph/ad_group.rb

@@ -0,0 +1,51 @@
+module GSGraph
+  class AdGroup < Node
+    include Connections::AdCreatives
+    include Connections::ReachEstimates
+
+    attr_accessor :ad_id, :campaign_id, :name, :adgroup_status, :bid_type, :max_bid, :targeting, :creative, :creative_ids, :adgroup_id,
+      :end_time, :start_time, :updated_time, :bid_info, :disapprove_reason_descriptions, :view_tags
+
+    def initialize(identifier, attributes = {})
+      super
+      set_attrs(attributes)
+    end
+
+    # We override update to handle the "redownload" parameter
+    # If redownload is specified, the GSGraph::AdGroup object will be updated with the data returned from Facebook.
+    def update(options)
+      response = super(options)
+
+      if options[:redownload]
+        attributes = options.merge(response[:data][:adgroups][identifier]).with_indifferent_access
+        set_attrs(attributes)
+      end
+
+      response
+    end
+
+    def creatives(fetch = true)
+      creative_ids.map { |creative_id| fetch ? AdCreative.fetch(creative_id) : AdCreative.new(creative_id) }
+    end
+
+    protected
+
+    def set_attrs(attributes)
+      %w(ad_id campaign_id name adgroup_status bid_type max_bid targeting creative creative_ids adgroup_id bid_info disapprove_reason_descriptions view_tags).each do |field|
+        send("#{field}=", attributes[field.to_sym])
+      end
+
+      # max_bid is string only when reloaded for some reason..
+      self.max_bid = max_bid.try(:to_i)
+
+      %w(start_time end_time updated_time).each do |field|
+        if val = attributes[field.to_sym]
+          # Handles integer timestamps and ISO8601 strings
+          time = Time.parse(val) rescue Time.at(val.to_i)
+          send("#{field}=", time)
+        end
+      end
+    end
+  end
+end
+

data/lib/gs_graph/ad_group_stat.rb

@@ -0,0 +1,22 @@
+module GSGraph
+  class AdGroupStat < Node
+    attr_accessor :start_time, :end_time, :adgroup_id, :impressions, :clicks, :spent, :social_impressions, :social_clicks, :social_spent,
+      :actions, :unique_impressions, :social_unique_impressions, :unique_clicks, :social_unique_clicks, :connections
+
+    def initialize(identifier, attributes = {})
+      super
+
+      %w(adgroup_id impressions clicks spent social_impressions social_clicks social_spent actions unique_impressions social_unique_impressions unique_clicks social_unique_clicks connections).each do |field|
+        send("#{field}=", attributes[field.to_sym])
+      end
+
+      %w(start_time end_time).each do |field|
+        if val = attributes[field.to_sym]
+          # Handles integer timestamps and ISO8601 strings
+          time = Time.parse(val) rescue Time.at(val.to_i)
+          send("#{field}=", time)
+        end
+      end
+    end
+  end
+end

data/lib/gs_graph/ad_keyword.rb

@@ -0,0 +1,20 @@
+module GSGraph
+  class AdKeyword < Node
+    extend Searchable
+
+    attr_accessor :name, :description
+
+    def initialize(identifier, attributes = {})
+      super
+
+      %w(name description).each do |field|
+        self.send("#{field}=", attributes[field.to_sym])
+      end
+    end
+
+    def topic_keyword?
+      (name =~ /^#/) == 0
+    end
+  end
+end
+

data/lib/gs_graph/ad_keyword_suggestion.rb

@@ -0,0 +1,8 @@
+module GSGraph
+  class AdKeywordSuggestion < AdKeyword
+    def self.search_query_param
+      :keyword_list
+    end
+  end
+end
+

data/lib/gs_graph/ad_keyword_valid.rb

@@ -0,0 +1,23 @@
+module GSGraph
+  class AdKeywordValid < Node
+    extend Searchable
+
+    attr_accessor :name, :valid, :suggestions
+
+    def initialize(identifier, attributes = {})
+      super
+
+      %w(name valid).each do |field|
+        self.send("#{field}=", attributes[field.to_sym])
+      end
+
+      self.suggestions = attributes[:suggestions].collect {|s| GSGraph::AdKeyword.new(s['id'], s)} if attributes[:suggestions]
+    end
+
+    alias :valid? :valid
+
+    def self.search_query_param
+      :keyword_list
+    end
+  end
+end

data/lib/gs_graph/ad_preview.rb

@@ -0,0 +1,10 @@
+module GSGraph
+  class AdPreview < Node
+    attr_accessor :preview_data
+
+    def initialize(attributes = {})
+      super
+      self.preview_data = Collection.new(attributes).first
+    end
+  end
+end

data/lib/gs_graph/ad_user.rb

@@ -0,0 +1,58 @@
+module GSGraph
+  class AdUser < User
+    attr_accessor :role, :permissions
+
+    def initialize(identifier, attributes = {})
+      super(identifier, attributes)
+
+      %w(role permissions).each do |field|
+        self.send("#{field}=", attributes[field.to_sym])
+      end
+    end
+
+    # Level 1001, administrator access
+    # Level 1002, general-user (ad manager) access
+    # Level 1003, reports-only access
+    ROLES = {
+      :admin        => 1001,
+      :general      => 1002,
+      :reports_only => 1003
+    }
+    ROLES.each do |key, value|
+      define_method "#{key}_access?" do
+        self.role == value
+      end
+    end
+
+    # 1: ACCOUNT_ADMIN: modify the set of users associated with the given account.
+    # 2: ADMANAGER_READ: view campaigns and ads
+    # 3: ADMANAGER_WRITE: manage campaigns and ads
+    # 4: BILLING_READ: view account billing information
+    # 5: BILLING_WRITE: modify the account billing information
+    # 7: REPORTS: run reports
+    PERMISSIONS = {
+      :account_admin => 1,
+      :ad_manager_read => 2,
+      :ad_manager_write => 3,
+      :billing_read => 4,
+      :billing_write => 5,
+      # what's "6"??
+      :reports => 7
+    }
+    PERMISSIONS.each do |key, value|
+      define_method "#{key}_access?" do
+        self.permissions.include? value
+      end
+    end
+
+    # GSGraph::User#fetch does not retrieve the permissions and roles since they are outside the normal
+    # attributes for an GSGraph::User, so we just copy them over from this object before returning
+    # the fetched one.
+    def fetch(options = {})
+      super(options).tap do |fetched|
+        fetched.role = role
+        fetched.permissions = permissions
+      end
+    end
+  end
+end

data/lib/gs_graph/age_range.rb

@@ -0,0 +1,12 @@
+module GSGraph
+  class AgeRange < Range
+    DEFAULT_MAX_AGE = 9999
+
+    def initialize(attributes = {})
+      super attributes[:min], attributes[:max] || DEFAULT_MAX_AGE
+    end
+
+    alias_method :min, :first
+    alias_method :max, :last
+  end
+end

data/lib/gs_graph/album.rb

@@ -0,0 +1,59 @@
+module GSGraph
+  class Album < Node
+    include Connections::Photos
+    include Connections::Comments
+    include Connections::Likes
+    include Connections::Likes::Likable
+    include Connections::Picture
+
+    attr_accessor :from, :name, :description, :location, :link, :cover_photo, :privacy, :count, :type, :created_time, :updated_time
+
+    def initialize(identifier, attributes = {})
+      super
+      @from = if (from = attributes[:from])
+        if from[:category]
+          Page.new(from[:id], from)
+        else
+          User.new(from[:id], from)
+        end
+      end
+      @name = attributes[:name]
+      # NOTE:
+      # for some reason, facebook uses different parameter names.
+      # "description" in GET & "message" in POST
+      @description = attributes[:description] || attributes[:message]
+      @location    = attributes[:location]
+      @link        = attributes[:link]
+      @privacy     = attributes[:privacy]
+      @count       = attributes[:count]
+      @type        = attributes[:type]
+
+      @cover_photo = if attributes[:cover_photo]
+        Photo.new(attributes[:cover_photo])
+      end
+      @created_time = if attributes[:created_time]
+        Time.parse(attributes[:created_time]).utc
+      end
+      @updated_time = if attributes[:updated_time]
+        Time.parse(attributes[:updated_time]).utc
+      end
+
+      # cached connection
+      cache_collection attributes, :comments
+    end
+
+    def picture_with_access_token(options_or_size = {})
+      response = picture_without_access_token options_or_size
+      if response.is_a?(GSGraph::Picture)
+        response
+      else
+        _endpoint_ = URI.parse response
+        if self.access_token
+          _endpoint_.query = [_endpoint_.query, {:access_token => self.access_token.to_s}.to_query].compact.join('&')
+        end
+        _endpoint_.to_s
+      end
+    end
+    alias_method_chain :picture, :access_token
+  end
+end

data/lib/gs_graph/app_request.rb

@@ -0,0 +1,24 @@
+module GSGraph
+  class AppRequest < Node
+
+    attr_accessor :application, :created_time, :data, :from, :message, :to
+
+    def initialize(identifier, attributes = {})
+      super
+      @data = attributes[:data]
+      @message = attributes[:message]
+      if attributes[:from]
+        @from = User.new(attributes[:from][:id], attributes[:from])
+      end
+      if attributes[:to]
+        @to = User.new(attributes[:to][:id], attributes[:to])
+      end
+      if attributes[:application]
+        @application = Application.new(attributes[:application][:id], attributes[:application])
+      end
+      if attributes[:created_time]
+        @created_time = Time.parse(attributes[:created_time]).utc
+      end
+    end
+  end
+end

data/lib/gs_graph/application.rb

@@ -0,0 +1,119 @@
+module GSGraph
+  class Application < Node
+    include Connections::Accounts
+    include Connections::Achievements
+    include Connections::AppNotifications
+    include Connections::Banned
+    include Connections::Insights
+    include Connections::Payments
+    include Connections::Picture
+    include Connections::Roles
+    include Connections::Subscriptions
+    include Connections::TestUsers
+    include Connections::Videos
+    include OpenGraph::ApplicationContext
+
+    @@attributes = [
+      :name,
+      :namespace,
+      :description,
+      :canvas_name,
+      :category,
+      :subcategory,
+      :link,
+      :company,
+      :icon_url,
+      :logo_url,
+      :daily_active_users,
+      :weekly_active_users,
+      :monthly_active_users,
+      :migrations,
+      :namespace,
+      :restrictions,
+      :app_domains,
+      :auth_dialog_data_help_url,
+      :auth_dialog_description,
+      :auth_dialog_headline,
+      :auth_dialog_perms_explanation,
+      :auth_referral_user_perms,
+      :auth_referral_friend_perms,
+      :auth_referral_default_activity_privacy,
+      :auth_referral_enabled,
+      :auth_referral_extended_perms,
+      :auth_referral_response_type,
+      :canvas_fluid_height,
+      :canvas_fluid_width,
+      :canvas_url,
+      :contact_email,
+      :created_time,
+      :creator_uid,
+      :deauth_callback_url,
+      :iphone_app_store_id,
+      :hosting_url,
+      :mobile_web_url,
+      :page_tab_default_name,
+      :page_tab_url,
+      :privacy_policy_url,
+      :secure_canvas_url,
+      :secure_page_tab_url,
+      :server_ip_whitelist,
+      :social_discovery,
+      :terms_of_service_url,
+      :user_support_email,
+      :user_support_url,
+      :website_url,
+      :type,
+      :secret
+    ]
+    attr_accessor *@@attributes
+
+    def initialize(client_id, attributes = {})
+      super
+      @@attributes.each do |key|
+        # NOTE:
+        # For some reason, Graph API returns daily_active_users, weekly_active_users, monthly_active_users as JSON string.
+        value = case key
+        when :daily_active_users, :weekly_active_users, :monthly_active_users
+          attributes[key].to_i
+        when :auth_referral_enabled, :canvas_fluid_height, :canvas_fluid_width, :social_discovery
+          case attributes[key]
+          when 1
+            true
+          when 0
+            false
+          else
+            attributes[key]
+          end
+        else
+          attributes[key]
+        end
+        self.send("#{key}=", value)
+      end
+    end
+
+    def get_access_token(secret = nil)
+      self.secret ||= secret
+      auth = Auth.new(self.identifier, self.secret)
+      self.access_token = auth.client.access_token! :client_auth_body
+    end
+    alias_method :app_access_token, :get_access_token
+
+    def access_token_with_auto_fetch
+      access_token_without_auto_fetch ||
+      self.secret && get_access_token
+    end
+    alias_method_chain :access_token, :auto_fetch
+
+    def debug_token(input_token)
+      _input_token_ = case input_token
+      when Rack::OAuth2::AccessToken::Legacy
+        input_token
+      else
+        Rack::OAuth2::AccessToken::Legacy.new(
+          :access_token => input_token
+        )
+      end
+      _input_token_.introspect access_token
+    end
+  end
+end

data/lib/gs_graph/auth.rb

@@ -0,0 +1,88 @@
+module GSGraph
+  class Auth
+    class VerificationFailed < BadRequest; end
+
+    attr_accessor :client, :access_token, :user, :data
+
+    def initialize(client_id, client_secret, options = {})
+      @client = Rack::OAuth2::Client.new(
+        :identifier             => client_id,
+        :secret                 => client_secret,
+        :host                   => URI.parse(GSGraph::graph_url).host,
+        :authorization_endpoint => '/oauth/authorize',
+        :token_endpoint         => '/oauth/access_token',
+        :redirect_uri           => options[:redirect_uri]
+      )
+      if options[:cookie]
+        from_cookie options[:cookie]
+      elsif options[:signed_request]
+        from_signed_request options[:signed_request]
+      end
+    end
+
+    def authorized?
+      self.access_token.present?
+    end
+
+    def authorize_uri(canvas_uri, options = {})
+      endpoint = URI.parse SignedRequest::oauth_dialog_endpoint
+      params = options.merge(
+        :client_id    => client.identifier,
+        :redirect_uri => canvas_uri
+      )
+      params[:scope] = Array(params[:scope]).join(',') if params[:scope].present?
+      endpoint.query = params.to_query
+      endpoint.to_s
+    end
+
+    def from_cookie(cookie)
+      self.data = Cookie.parse(client, cookie)
+      get_access_token! data[:code]
+      self
+    end
+
+    def from_signed_request(signed_request)
+      self.data = SignedRequest.verify(client, signed_request)
+      if self.data[:oauth_token]
+        self.access_token = build_access_token(data)
+        self.user = User.new(data[:user_id], :access_token => self.access_token)
+      end
+      self
+    end
+
+    def exchange_token!(access_token)
+      raise Unauthorized.new('No Access Token') unless access_token
+      client.fb_exchange_token = access_token
+      self.access_token = client.access_token! :client_auth_body
+      self
+    rescue Rack::OAuth2::Client::Error => e
+      Exception.handle_rack_oauth2_error e
+    end
+
+    private
+
+    def get_access_token!(code)
+      raise Unauthorized.new('No Authorization Code') unless code
+      client.redirect_uri = ''
+      client.authorization_code = code
+      self.access_token = client.access_token! :client_auth_body
+      self.user = User.new(data[:user_id], :access_token => access_token)
+      self
+    rescue Rack::OAuth2::Client::Error => e
+      Exception.handle_rack_oauth2_error e
+    end
+
+    def build_access_token(data)
+      expires_in = unless data[:expires].nil? || data[:expires].zero?
+        data[:expires] - Time.now.to_i
+      end
+      Rack::OAuth2::AccessToken::Legacy.new(
+        :access_token => data[:oauth_token] || data[:access_token],
+        :expires_in   => expires_in
+      )
+    end
+  end
+end
+
+require 'gs_graph/auth/cookie'
+require 'gs_graph/auth/signed_request'