palidanx-fb_graph 1.0.4

data/lib/fb_graph/application.rb

@@ -0,0 +1,57 @@
+module FbGraph
+  class Application < Node
+    include Connections::Feed
+    include Connections::Posts
+    include Connections::Picture
+    include Connections::Tagged
+    include Connections::Links
+    include Connections::Photos
+    include Connections::Albums
+    include Connections::Statuses
+    include Connections::Videos
+    include Connections::Notes
+    include Connections::Events
+    include Connections::Subscriptions
+    include Connections::Insights
+
+    attr_accessor :name, :description, :category, :link, :secret
+
+    def initialize(client_id, attributes = {})
+      super
+      @name         = attributes[:name]
+      @description  = attributes[:description]
+      @category     = attributes[:category]
+      @link         = attributes[:link]
+      @secret       = attributes[:secret]
+    end
+
+    # == Get OAuth access token
+    # 
+    # Obtain an OAuth access token associated with your application via the OAuth Client Credentials Flow.
+    # 
+    # ref) http://developers.facebook.com/docs/api#analytics
+    # 
+    #   app = FbGraph::Application.new(APP_ID)
+    #   app.get_access_token
+    #   # => access token as String
+    #   app.access_token # once get_access_token is called, access token is cached.
+    #   # => access token as String
+    # 
+    # This method is automatically called when access token needed and application secret has already given.
+    # 
+    #   app = FbGraph::Application.new(APP_ID, :secret => APP_SECRET)
+    #   app.subscriptions # get_access_token is called automatically
+    #   # => Array of FbGraph::Subscription
+    def get_access_token(secret = nil)
+      self.secret ||= secret
+      auth = FbGraph::Auth.new(self.identifier, self.secret)
+      response_string = auth.client.request(:post, auth.client.access_token_url, {
+        :client_id => self.identifier,
+        :client_secret => self.secret,
+        :type => 'client_cred'
+      })
+      self.access_token = response_string.split('=').last
+    end
+
+  end
+end

data/lib/fb_graph/auth.rb

@@ -0,0 +1,52 @@
+module FbGraph
+  # = Parse & verify facebook auth cookie
+  # 
+  # Used with Facebook JavaScript SDK
+  # 
+  #   app = FbGraph::Auth.new(APP_ID, APP_SECRET)
+  #   app.from_cookie(cookie_hash)
+  #   auth.access_token
+  #   # => OAuth2::AccessToken (not String!)
+  #   auth.user # only initialized
+  #   auth.user.fetch # fetch whole profile
+  # 
+  # This method is called automatically if cookie is given when initializing
+  # 
+  #   auth = FbGraph::Auth.new(APP_ID, APP_SECRET, :cookie => {..})
+  #   auth.access_token # already parsed
+  class Auth
+    class VerificationFailed < FbGraph::Exception; end
+
+    attr_accessor :client, :access_token, :user
+
+    def initialize(client_id, client_secret, options = {})
+      @client = OAuth2::Client.new(client_id, client_secret, options.merge(
+        :site => FbGraph::ROOT_URL
+      ))
+      if options[:cookie].present?
+        from_cookie(options[:cookie])
+      end
+    end
+
+    def from_cookie(cookie)
+
+      #this creates a cookie
+      cookie = FbGraph::Auth::Cookie.parse(self.client, cookie)
+
+      #the cookie expires time is the time as an integer
+      #in the oauth2 api, it does Time.now + expires, creating a time too large
+      #instead, make expires a delta value
+      time_expires = cookie[:expires].to_i - Time.now.to_i
+      self.access_token = OAuth2::AccessToken.new(
+        self.client,
+        cookie[:access_token],
+        cookie[:refresh_token],
+        time_expires
+      )
+      self.user = FbGraph::User.new(cookie[:uid], :access_token => self.access_token)
+      self
+    end
+  end
+end
+
+require 'fb_graph/auth/cookie'

data/lib/fb_graph/auth/cookie.rb

@@ -0,0 +1,43 @@
+require 'digest/md5'
+
+module FbGraph
+  class Auth
+    # NOTE:
+    # If you want access token, use FbGraph::Auth.new(APP_ID, APP_SECRET, :cookie => {..}) instead
+    class Cookie
+      def self.parse(client, cookie)
+        fb_cookie_string = if cookie.is_a?(Hash)
+          cookie["fbs_#{client.id}"]
+        else
+          cookie
+        end
+
+        raise VerificationFailed.new(401, 'Facebook cookie not found') if fb_cookie_string.blank?
+
+        fb_cookie_string.gsub!(/[\\"]/, '')
+        signature, fb_cookie = '', {}
+        fb_cookie_string.split('&').each do |kv|
+          k, v = kv.split('=')
+          if k == 'sig'
+            signature = v
+          else
+            v = v.to_i if ['uid', 'expires'].include?(k)
+            fb_cookie[k] = v
+          end
+        end
+
+        signature_base_string = fb_cookie.to_a.sort do |a, b|
+          a[0] <=> b[0] || a[1] <=> b[1]
+        end.map do |(k, v)|
+          "#{k}=#{v}"
+        end.join
+
+        unless Digest::MD5.hexdigest("#{signature_base_string}#{client.secret}") == signature
+          raise VerificationFailed.new(401, 'Facebook cookie signature invalid')
+        end
+
+        fb_cookie.with_indifferent_access
+      end
+    end
+  end
+end

data/lib/fb_graph/checkin.rb

@@ -0,0 +1,44 @@
+module FbGraph
+  class Checkin < Node
+    extend Searchable
+
+    attr_accessor :from, :tags, :place, :message, :coordinates, :application, :created_time
+
+    def initialize(identifier, attributes = {})
+      super
+      if (from = attributes[:from])
+        @from = FbGraph::User.new(from.delete(:id), from)
+      end
+      @tags = []
+      if (tags = attributes[:tags])
+        FbGraph::Collection.new(tags).each do |user|
+          @tags << FbGraph::User.new(user.delete(:id), user)
+        end
+      end
+      if (place = attributes[:place])
+        @place = FbGraph::Page.new(place.delete(:id), place)
+      end
+      @message = attributes[:message]
+      if (coordinates = attributes[:coordinates])
+        # NOTE: it seems this attributes isn't used now
+        @coordinates = FbGraph::Venue.new(location)
+      end
+      if (application = attributes[:application])
+        @application = FbGraph::Application.new(application.delete(:id), application)
+      end
+      if (created_time = attributes.delete(:created_time))
+        @created_time = Time.parse(created_time).utc
+      end
+    end
+
+    # == Search for recent check-ins for an authorized user and his or her friends:
+    # 
+    #   FbGraph::Checkin.search(:access_token => ACCESS_TOKEN)
+    #   # => Array of FbGraph::Checkin
+    def self.search(options = {})
+      # NOTE:
+      # checkin search doesn't support "q=***" parameter
+      super(nil, options)
+    end
+  end
+end

data/lib/fb_graph/collection.rb

@@ -0,0 +1,44 @@
+module FbGraph
+  class Collection < Array
+    attr_reader :previous, :next, :total_count
+
+    def initialize(collection = nil)
+      collection = case collection
+      when Array
+        {:data => collection, :count => collection.size}
+      when Hash
+        collection[:data] ||= []
+        collection
+      when nil
+        collection = {:data => [], :count => 0}
+      else
+        raise "Invalid collection"
+      end
+      result = replace(collection[:data])
+      @total_count = collection[:count]
+      @previous, @next = {}, {}
+      if (paging = collection[:paging])
+        if paging[:previous]
+          @previous = fetch_params(paging[:previous])
+        end
+        if paging[:next]
+          @next = fetch_params(paging[:next])
+        end
+      end
+    end
+
+    private
+
+    def fetch_params(url)
+      query = URI.parse(url).query
+      params = {}
+      query.split('&').each do |q|
+        key, value = q.split('=')
+        params[key] = URI.unescape(value)
+      end
+      params.delete_if do |k, v|
+        !['limit', 'offset', 'until', 'since'].include?(k)
+      end
+    end
+  end
+end

data/lib/fb_graph/comment.rb

@@ -0,0 +1,20 @@
+module FbGraph
+  class Comment < Node
+    attr_accessor :from, :message, :created_time
+
+    def initialize(identifier, attributes = {})
+      super
+      if (from = attributes[:from])
+        @from = if from[:category]
+          FbGraph::Page.new(from.delete(:id), from)
+        else
+          FbGraph::User.new(from.delete(:id), from)
+        end
+      end
+      @message = attributes[:message]
+      if attributes[:created_time]
+        @created_time = Time.parse(attributes[:created_time]).utc
+      end
+    end
+  end
+end

data/lib/fb_graph/comparison.rb

@@ -0,0 +1,9 @@
+module FbGraph
+  module Comparison
+    def ==(other)
+      instance_variables.all? do |key|
+        instance_variable_get(key) == other.instance_variable_get(key)
+      end
+    end
+  end
+end

data/lib/fb_graph/connection.rb

@@ -0,0 +1,30 @@
+module FbGraph
+  class Connection < Collection
+    attr_accessor :collection, :connection, :owner, :options
+
+    def initialize(owner, connection, options = {})
+      @owner = owner
+      @options = options
+      @connection = connection
+      @collection = options.delete(:collection) || FbGraph::Collection.new
+      replace collection
+    end
+
+    def next(_options_ = {})
+      if self.collection.next.present?
+        self.owner.send(self.connection, self.options.merge(_options_).merge(self.collection.next))
+      else
+        self.class.new(self.owner, self.connection)
+      end
+    end
+
+    def previous(_options_ = {})
+      puts self.options.inspect
+      if self.collection.previous.present?
+        self.owner.send(self.connection, self.options.merge(_options_).merge(self.collection.previous))
+      else
+        self.class.new(self.owner, self.connection)
+      end
+    end
+  end
+end

data/lib/fb_graph/connections.rb

@@ -0,0 +1,3 @@
+Dir[File.dirname(__FILE__) + '/connections/*.rb'].each do |file| 
+  require file
+end

data/lib/fb_graph/connections/accounts.rb

@@ -0,0 +1,58 @@
+module FbGraph
+  module Connections
+    # = What's "accounts"?
+    #
+    # Pages owned by the current user.
+    #
+    # ref) http://developers.facebook.com/docs/api#impersonation
+    #
+    # = Authentication
+    #
+    # * Access token is required.
+    # * "manage_pages" permission is optional.
+    #
+    # If the "manage_pages" permission has been granted,
+    # this connection also yields access_tokens that can be used to query the Graph API on behalf of the page.
+    #
+    # ref) http://developers.facebook.com/docs/reference/api/user
+    #
+    # = Connected with
+    #
+    # * FbGraph::User
+    #
+    # == Fetch
+    #
+    #   pages = FbGraph::User.me(ACCESS_TOKEN).accounts
+    #   # => array of FbGraph::Page
+    #   pages.first.access_token
+    #   # => String if "manage_pages" permission has been granted, nil if not.
+    #
+    # = Notes
+    #
+    # == Access token of the page
+    #
+    # Using given access token, you can do those things as the page, not as yourself.
+    #
+    # * update the page's wall
+    # * create new page's album and upload photos into it
+    # * create and manage an event
+    # * etc.
+    #
+    # See RDoc for FbGraph::Page for more details.
+    #
+    #   page = FbGraph::User.me(ACCESS_TOKEN).accounts.first
+    #   page.access_token
+    #   # => given because "manage_pages" permission has been granted.
+    #   page.feed!(:message => 'Updating via FbGraph')
+    #   # => update the page's wall, not the user's wall
+    module Accounts
+      def accounts(options = {})
+        accounts = self.connection(:accounts, options)
+        accounts.map! do |account|
+          account[:access_token] ||= options[:access_token] || self.access_token
+          FbGraph::Page.new(account.delete(:id), account)
+        end
+      end
+    end
+  end
+end

data/lib/fb_graph/connections/activities.rb

@@ -0,0 +1,14 @@
+module FbGraph
+  module Connections
+    module Activities
+      def activities(options = {})
+        activities = self.connection(:activities, options)
+        activities.map! do |activity|
+          FbGraph::Page.new(activity.delete(:id), activity.merge(
+            :access_token => options[:access_token] || self.access_token
+          ))
+        end
+      end
+    end
+  end
+end

data/lib/fb_graph/connections/albums.rb

@@ -0,0 +1,96 @@
+module FbGraph
+  module Connections
+    # = Authentication
+    #
+    # * Access token is required to fetch/create albums.
+    # * "publish_stream" permissin is required to create new album.
+    #
+    # = Connected with
+    #
+    # * FbGraph::Application
+    # * FbGraph::USer
+    # * FbGraph::Page
+    #
+    # = Example
+    #
+    # == Fetch albums
+    #
+    #   me = FbGraph::User.me(ACCESS_TOKEN)
+    #   me.albums
+    #   # => Array of FbGraph::Album
+    #
+    #   page = FbGraph::Page.new('fb_graph')
+    #   page.albums
+    #   # => Array of FbGraph::Album
+    #
+    # == Create an album
+    #
+    #   me = FbGraph::User.me(ACCESS_TOKEN)
+    #   album = me.album!(
+    #     :name => 'FbGraph test',
+    #     :message => 'hello world!',
+    #     :description => 'hello world!'
+    #   )
+    #
+    #   page = FbGraph::Page.new('fb_graph', :access_token => ACCESS_TOKEN)
+    #   album = page.album!(
+    #     :name => 'FbGraph test',
+    #     :message => 'hello world!',
+    #     :description => 'hello world!'
+    #   )
+    #
+    # = Notes
+    #
+    # == Attributes after created
+    #
+    # Only attributes you specified are saved in the created album object.
+    # If you want to access any other attributes, you need to fetch the album info via Graph API.
+    #
+    #   me = FbGraph::User.me(ACCESS_TOKEN)
+    #   album = me.album!(
+    #     :name => 'FbGraph test',
+    #     :message => 'hello world!',
+    #     :description => 'hello world!'
+    #   )
+    #   album.name # => 'FbGraoh test'
+    #   album.from # => nil
+    #   album.created_time # => nil
+    #   album.fetch
+    #   album.from # => me
+    #   album.created_time # => Sun Sep 12 01:18:36 +0900 2010
+    #
+    # == Bug of Graph API
+    #
+    # According facebook's document, the key for +description+ should be +description+ both when fetching and creating,
+    # but actually you need to use +message+ instead of +description+ only when creating.
+    # It probably facebook's bug, and it might be fixed suddenly.
+    # I highly recommend to send same value both as +description+ and +message+ when creating,
+    # then your code will work without any code change.
+    #
+    # ref) http://developers.facebook.com/docs/reference/api/album
+    #
+    #   me = FbGraph::User.me(ACCESS_TOKEN)
+    #   album = me.album!(
+    #     :name => 'FbGraph test',
+    #     :message => 'hello world!',
+    #     :description => 'hello world!'
+    #   )
+    module Albums
+      def albums(options = {})
+        albums = self.connection(:albums, options)
+        albums.map! do |album|
+          Album.new(album.delete(:id), album.merge(
+            :access_token => options[:access_token] || self.access_token
+          ))
+        end
+      end
+
+      def album!(options = {})
+        album = post(options.merge(:connection => 'albums'))
+        Album.new(album.delete(:id), options.merge(album).merge(
+          :access_token => options[:access_token] || self.access_token
+        ))
+      end
+    end
+  end
+end