tenderlove-facebooker 1.0.16.20090319151701

data/lib/facebooker/admin.rb

@@ -0,0 +1,42 @@
+module Facebooker
+  class Admin
+    def initialize(session)
+      @session = session
+    end
+    
+    # ** BETA ***
+    # +properties+: Hash of properties you want to set
+    def set_app_properties(properties)
+      properties = properties.respond_to?(:to_json) ? properties.to_json : properties
+      (@session.post 'facebook.admin.setAppProperties', :properties => properties) == '1'
+    end
+    
+    # ** BETA ***
+    # +properties+: Hash of properties you want to view.
+    def get_app_properties(*properties)
+      json = @session.post('facebook.admin.getAppProperties', :properties => properties.to_json)
+      hash = Facebooker.json_decode(CGI.unescapeHTML(json))
+      @properties = ApplicationProperties.from_hash(hash)
+    end
+    
+    # ** BETA ***
+    # +restrictions+: Hash of restrictions you want to set.
+    def set_restriction_info(restrictions)
+      restrictions = restrictions.respond_to?(:to_json) ? restrictions.to_json : restrictions
+      (@session.post 'facebook.admin.setRestrictionInfo', :restriction_str => restrictions) == '1'
+    end
+    
+    # ** BETA ***
+    def get_restriction_info(*restrictions)
+      json = @session.post('facebook.admin.getRestrictionInfo')
+      hash = Facebooker.json_decode(CGI.unescapeHTML(json))
+      @restrictions = ApplicationRestrictions.from_hash(hash)
+    end
+  
+    # Integration points include..
+    #   :notifications_per_day, :requests_per_day, :emails_per_day, :email_disable_message_location
+    def get_allocation(integration_point)
+      @session.post('facebook.admin.getAllocation', :integration_point_name => integration_point.to_s).to_i
+    end    
+  end
+end

data/lib/facebooker/batch_request.rb

@@ -0,0 +1,44 @@
+module Facebooker
+  class BatchRequest
+    instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^respond_to\?$|^new$)/ }
+    attr_reader :uri
+    attr_reader :method
+    class UnexecutedRequest < StandardError; end
+    def initialize(params,proc)
+      @method=params[:method]
+      @uri=params.map{|k,v| "#{k}=#{CGI.escape(v.to_s)}"}.join("&")
+      @proc=proc
+    end
+  
+    def result=(result_object)
+      @result = @proc.nil? ? result_object : @proc.call(result_object)
+    end
+    
+    def exception_raised=(ex)
+      @exception=ex
+    end
+    
+    def exception_raised?
+      @exception.nil? ? false : raise(@exception)
+    end
+
+    def respond_to?(name)
+      super || @result.respond_to?(name)
+    end
+  
+    def ===(other)
+      other === @result
+    end
+  
+  
+    def method_missing(name,*args,&proc)
+      if @exception
+        raise @exception
+      elsif @result.nil?
+        raise UnexecutedRequest.new("You must execute the batch before accessing the result: #{@uri}")
+      else
+        @result.send(name,*args,&proc)
+      end
+    end
+  end
+end

data/lib/facebooker/data.rb

@@ -0,0 +1,57 @@
+module Facebooker
+  class Data
+    def initialize(session)
+      @session = session
+    end
+    
+    ##
+    # ** BETA ***
+    # Sets a cookie on Facebook
+    # +user+ The user for whom this cookie needs to be set.
+    # +name+ Name of the cookie
+    # +value+ Value of the cookie
+    # Optional:
+    # +expires+ Time when the cookie should expire. If not specified, the cookie never expires. 
+    # +path+ Path relative to the application's callback URL, with which the cookie should be associated. (default value is /?
+    def set_cookie(user, name, value, expires=nil, path=nil)
+      @session.post('facebook.data.setCookie', 
+        :uid => User.cast_to_facebook_id(user), 
+        :name => name, 
+        :value => value, 
+        :expires => expires, 
+        :path => path) {|response| response == '1'}
+    end
+    
+    ##
+    # ** BETA ***
+    # Gets a cookie stored on Facebook
+    # +user+	The user from whom to get the cookies.	
+    # Optional:   
+    # +name+ The name of the cookie. If not specified, all the cookies for the given user get returned.
+    def get_cookies(user, name=nil)
+      @cookies = @session.post( 
+        'facebook.data.getCookies', :uid => User.cast_to_facebook_id(user), :name => name) do |response|
+          response.map do |hash|
+            Cookie.from_hash(hash)
+          end
+      end
+    end   
+    
+    ##
+    # ** BETA ***
+    # Gets a preference stored on Facebook
+    # +pref_id+	The id of the preference to get
+    def get_preference(pref_id)
+      @session.post('facebook.data.getUserPreference', :pref_id=>pref_id)
+    end
+
+    ##
+    # ** BETA ***
+    # Sets a preference on Facebook
+    # +pref_id+	The id of the preference to set
+    # +value+ The value to set for this preference
+    def set_preference(pref_id, value)
+      @session.post('facebook.data.setUserPreference', :pref_id=>pref_id, :value=>value)
+    end
+  end
+end

data/lib/facebooker/feed.rb

@@ -0,0 +1,78 @@
+module Facebooker
+  module Feed
+    METHODS = {'Action' => 'facebook.feed.publishActionOfUser', 'Story' => 'facebook.feed.publishStoryToUser',
+               'TemplatizedAction' => 'facebook.feed.publishTemplatizedAction' }
+
+    class ActionBase
+      1.upto(4) do |num|
+        attr_accessor "image_#{num}"
+        attr_accessor "image_#{num}_link"
+      end
+      
+      def add_image(image,link=nil)
+        1.upto(4) do |num|
+          if send("image_#{num}").blank?
+            send("image_#{num}=",image)
+            send("image_#{num}_link=",link) unless link.nil?
+            return num
+          end
+        end        
+      end
+      
+
+      protected
+      def image_params
+        image_hash = {}
+        1.upto(4) do |num|
+          image_attribute = "image_#{num}"
+          image_link_attribute = image_attribute + "_link"
+          self.__send__(image_attribute) ? image_hash[image_attribute] = self.__send__(image_attribute) : nil
+          self.__send__(image_link_attribute) ? image_hash[image_link_attribute] = self.__send__(image_link_attribute) : nil    
+        end
+        image_hash
+      end
+    end
+
+    ##
+    # Representation of a templatized action to be published into a user's news feed
+    class TemplatizedAction < ActionBase
+     attr_accessor :page_actor_id, :title_template, :title_data, :body_template, :body_data, :body_general, :target_ids
+
+      def to_params
+       raise "Must set title_template" if self.title_template.nil?
+       { :page_actor_id => page_actor_id, 
+         :title_template => title_template, 
+         :title_data => convert_json(title_data),
+         :body_template => body_template, 
+         :body_data => convert_json(body_data), 
+         :body_general => body_general,
+         :target_ids => target_ids }.merge image_params
+      end
+      
+      def convert_json(hash_or_string)    
+        (hash_or_string.is_a?(Hash) and hash_or_string.respond_to?(:to_json)) ? hash_or_string.to_json : hash_or_string
+      end
+    end
+
+    ##
+    # Representation of a story to be published into a user's news feed.
+    class Story < ActionBase
+      attr_accessor :title, :body
+
+      ##
+      # Converts Story to a Hash of its attributes for use as parameters to Facebook REST API calls
+      def to_params
+        raise "Must set title before converting" if self.title.nil?
+        { :title => title, :body => body }.merge image_params
+      end
+
+    end
+    Action = Story.dup
+    def Action.name
+      "Action"
+    end
+    ##
+    #  Representation of an action to be published into a user's news feed.  Alias for Story.
+    class Action; end
+  end
+end

data/lib/facebooker/logging.rb

@@ -0,0 +1,51 @@
+require 'benchmark'
+module Facebooker
+  @@logger = nil
+  def self.logger=(logger)
+    @@logger = logger
+  end
+  def self.logger
+    @@logger
+  end
+
+  module Logging
+    
+    def self.skip_api_logging=(val)
+      @skip_api_logging=val
+    end
+    
+    def self.skip_api_logging
+      @skip_api_logging
+    end
+    
+    
+    def self.log_fb_api(method, params)
+      message = method # might customize later
+      dump = format_fb_params(params)
+      if block_given?
+        result = nil
+        seconds = Benchmark.realtime { result = yield }
+        log_info(message, dump, seconds) unless skip_api_logging
+        result
+      else
+        log_info(message, dump) unless skip_api_logging
+        nil
+      end
+    rescue Exception => e
+      exception = "#{e.class.name}: #{e.message}: #{dump}"
+      log_info(message, exception)
+      raise
+    end
+    
+    def self.format_fb_params(params)
+      params.map { |key,value| "#{key} = #{value}" }.join(', ')
+    end
+    
+    def self.log_info(message, dump, seconds = 0)
+      return unless Facebooker.logger
+      log_message = "#{message} (#{seconds}) #{dump}"
+      Facebooker.logger.debug(log_message)
+    end
+    
+  end  
+end

data/lib/facebooker/mobile.rb

@@ -0,0 +1,20 @@
+module Facebooker
+  class Mobile
+    def initialize(session)
+      @session = session
+    end
+  
+    # Used to determine whether the user identified by "uid" has enabled SMS for this application.
+    def can_send(user)
+      @session.post('facebook.sms.canSend', :uid => User.cast_to_facebook_id(user))
+    end
+    
+    # Send the given message to the user.
+    # See http://wiki.developers.facebook.com/index.php/Mobile
+    def send(user, message)
+      @session.post('facebook.sms.send', 
+        {:uid => User.cast_to_facebook_id(user), 
+        :message => message}, false)
+    end
+  end
+end

data/lib/facebooker/mock/service.rb

@@ -0,0 +1,50 @@
+require 'digest/md5'
+require 'facebooker/service'
+
+module Facebooker
+  # A mock service that reads the Facebook response from fixtures
+  # Adapted from http://gist.github.com/44344
+  #
+  #   Facebooker::MockService.fixture_path = 'path/to/dir'
+  #   Facebooker::Session.current = Facebooker::MockSession.create
+  #
+  class MockService < Service
+    class << self
+      attr_accessor :fixture_path
+    end
+
+    def read_fixture(method, filename, original = nil)
+      path = fixture_path(method, filename)
+      File.read path
+    rescue Errno::ENAMETOOLONG
+      read_fixture(method, hash_fixture_name(filename), filename)
+    rescue Errno::ENOENT => e
+      if File.exists?(fixture_path(method, 'default'))
+        File.read fixture_path(method, 'default')
+      else
+        e.message << "\n(Non-hashed path is #{original})" if original
+        e.message << "\nFacebook API Reference: http://wiki.developers.facebook.com/index.php/#{method.sub(/^facebook\./, '')}#Example_Return_XML"
+        raise e
+      end
+    end
+
+    def post(params)
+      method = params.delete(:method)
+      params.delete_if {|k,_| [:v, :api_key, :call_id, :sig].include?(k) }
+      Parser.parse(method, read_fixture(method, fixture_name(params)))
+    end
+
+  private
+    def fixture_path(method, filename)
+      File.join(self.class.fixture_path, method, "#{filename}.xml")
+    end
+
+    def hash_fixture_name(filename)
+      Digest::MD5.hexdigest(filename)
+    end
+
+    def fixture_name(params)
+      params.map {|*args| args.join('=') }.sort.join('&')
+    end
+  end
+end

data/lib/facebooker/mock/session.rb

@@ -0,0 +1,18 @@
+require 'facebooker/session'
+
+module Facebooker
+  class MockSession < Session
+    def secured?
+      true
+    end
+
+    def secure!
+      @uid = 1
+      true
+    end
+ 
+    def service
+      @service ||= MockService.new(Facebooker.api_server_base, Facebooker.api_rest_path, @api_key)
+    end
+  end
+end

data/lib/facebooker/model.rb

@@ -0,0 +1,135 @@
+module Facebooker
+  ##
+  # helper methods primarily supporting the management of Ruby objects which are populatable via Hashes.  
+  # Since most Facebook API calls accept and return hashes of data (as XML), the Model module allows us to
+  # directly populate a model's attributes given a Hash with matching key names.
+  module Model
+    class UnboundSessionException < Exception; end
+    def self.included(includer)
+      includer.extend ClassMethods
+      includer.__send__(:attr_writer, :session)
+      includer.__send__(:attr_reader, :anonymous_fields)
+    end
+    module ClassMethods
+      ##
+      # Instantiate a new instance of the class into which we are included and populate that instance's
+      # attributes given the provided Hash.  Key names in the Hash should map to attribute names on the model.
+      def from_hash(hash)
+        instance = new(hash)
+        yield instance if block_given?
+        instance
+      end
+      
+      ##
+      # Create a standard attr_writer and a populating_attr_reader      
+      def populating_attr_accessor(*symbols)
+        attr_writer *symbols
+        populating_attr_reader *symbols
+      end
+
+      ## 
+      # Create a reader that will attempt to populate the model if it has not already been populated
+      def populating_attr_reader(*symbols)
+        symbols.each do |symbol|
+          define_method(symbol) do
+            populate unless populated?
+            instance_variable_get("@#{symbol}")
+          end
+        end
+      end
+      
+      def populating_hash_settable_accessor(symbol, klass)
+        populating_attr_reader symbol
+        hash_settable_writer(symbol, klass)
+      end
+        
+      def populating_hash_settable_list_accessor(symbol, klass)
+        populating_attr_reader symbol
+        hash_settable_list_writer(symbol, klass)
+      end
+      
+      #
+      # Declares an attribute named ::symbol:: which can be set with either an instance of ::klass::
+      # or a Hash which will be used to populate a new instance of ::klass::.
+      def hash_settable_accessor(symbol, klass)
+        attr_reader symbol
+        hash_settable_writer(symbol, klass)
+      end
+      
+      def hash_settable_writer(symbol, klass)
+        define_method("#{symbol}=") do |value|
+          instance_variable_set("@#{symbol}", value.kind_of?(Hash) ? klass.from_hash(value) : value)
+        end        
+      end
+      
+      #
+      # Declares an attribute named ::symbol:: which can be set with either a list of instances of ::klass::
+      # or a list of Hashes which will be used to populate a new instance of ::klass::.      
+      def hash_settable_list_accessor(symbol, klass)
+        attr_reader symbol
+        hash_settable_list_writer(symbol, klass)
+      end
+      
+      def hash_settable_list_writer(symbol, klass)
+        define_method("#{symbol}=") do |list|
+          instance_variable_set("@#{symbol}", list.map do |item|
+            item.kind_of?(Hash) ? klass.from_hash(item) : item
+          end)
+        end
+      end      
+
+      def id_is(attribute)
+        class_eval <<-EOS
+        def #{attribute}=(value)
+          @#{attribute} = value.to_i
+        end
+
+        attr_reader #{attribute.inspect}
+        alias :id #{attribute.inspect}
+        alias :id= #{"#{attribute}=".to_sym.inspect}
+        EOS
+      end
+    end
+    
+    ##
+    # Centralized, error-checked place for a model to get the session to which it is bound.
+    # Any Facebook API queries require a Session instance.
+    def session
+      @session || (raise UnboundSessionException, "Must bind this object to a Facebook session before querying")
+    end
+    
+    # 
+    # This gets populated from FQL queries.
+    def anon=(value)
+      @anonymous_fields = value
+    end
+    
+    def initialize(hash = {})
+      populate_from_hash!(hash)
+    end
+
+    def populate
+      raise NotImplementedError, "#{self.class} included me and should have overriden me"
+    end
+
+    def populated?
+      !@populated.nil?
+    end
+    
+    ##
+    # Set model's attributes via Hash.  Keys should map directly to the model's attribute names.
+    def populate_from_hash!(hash)
+      unless hash.nil? || hash.empty?
+        hash.each do |key, value|
+          set_attr_method = "#{key}="
+          if !value.nil? && respond_to?(set_attr_method)
+            self.__send__(set_attr_method, value) 
+          else
+            Facebooker::Logging.log_info("**Warning**, Attempt to set non-attribute: #{key}",hash)
+          end
+        end
+        @populated = true
+      end      
+    end    
+  end
+end

data/lib/facebooker/models/affiliation.rb

@@ -0,0 +1,10 @@
+require 'facebooker/model'
+module Facebooker
+  ##
+  # Represents a user's affiliation, for example, which educational institutions
+  # the user is associated with.
+  class Affiliation
+    include Model
+    attr_accessor :name, :status, :type, :year, :nid
+  end
+end

data/lib/facebooker/models/album.rb

@@ -0,0 +1,11 @@
+require 'facebooker/model'
+module Facebooker
+  ##
+  # A simple representation of a photo album.
+  class Album
+    include Model
+    attr_accessor :aid, :cover_pid, :owner, :name, :created,
+                  :modified, :description, :location, :link, :size
+
+  end
+end

data/lib/facebooker/models/applicationproperties.rb

@@ -0,0 +1,39 @@
+module Facebooker
+  
+  # application_name  string   The name of your application.  
+  # callback_url  string   Your application's callback URL. The callback URL cannot be longer than 100 characters.  
+  # post_install_url  string   The URL where a user gets redirected after installing your application. The post-install URL cannot be longer than 100 characters. 
+  # edit_url  string    
+  # dashboard_url string    
+  # uninstall_url string   The URL where a user gets redirected after removing your application.  
+  # ip_list string   For Web-based applications, these are the IP addresses of your servers that can access Facebook's servers and serve information to your application. 
+  # email string   The email address associated with the application; the email address Facebook uses to contact you about your application. (default value is your Facebook email address.)  
+  # description string   The description of your application. 
+  # use_iframe  bool   Indicates whether you render your application with FBML (0) or in an iframe (1). (default value is 1)  
+  # desktop bool   Indicates whether your application is Web-based (0) or gets installed on a user's desktop (1). (default value is 1)  
+  # is_mobile bool   Indicates whether your application can run on a mobile device (1) or not (0). (default value is 1) 
+  # default_fbml  string   The default FBML code that appears in the user's profile box when he or she adds your application. 
+  # default_column  bool   Indicates whether your application appears in the wide (1) or narrow (0) column of a user's Facebook profile. (default value is 1) 
+  # message_url string   For applications that can create attachments, this is the URL where you store the attachment's content.  
+  # message_action  string   For applications that can create attachments, this is the label for the action that creates the attachment. It cannot be more than 20 characters.  
+  # about_url string   This is the URL to your application's About page. About pages are now Facebook Pages.  
+  # private_install bool   Indicates whether you want to disable (1) or enable (0) News Feed and Mini-Feed stories when a user installs your application. (default value is 1)  
+  # installable bool   Indicates whether a user can (1) or cannot (0) install your application. (default value is 1)  
+  # privacy_url string   The URL to your application's privacy terms. 
+  # help_url  string   The URL to your application's help page. 
+  # see_all_url string    
+  # tos_url string   The URL to your application's Terms of Service.  
+  # dev_mode  bool   Indicates whether developer mode is enabled (1) or disabled (0). Only developers can install applications in developer mode. (default value is 1)  
+  # preload_fql string   A preloaded FQL query.
+  class ApplicationProperties
+    include Model
+    FIELDS = [ :application_name, :callback_url, :post_install_url, :edit_url, :dashboard_url,
+               :uninstall_url, :ip_list, :email, :description, :use_iframe, :desktop, :is_mobile,
+               :default_fbml, :default_column, :message_url, :message_action, :about_url,
+               :private_install, :installable, :privacy_url, :help_url, :see_all_url, :tos_url,
+               :dev_mode, :preload_fql, :icon_url, :canvas_name, :logo_url, :connect_logo_url ]
+    
+    attr_accessor *FIELDS
+         
+  end
+end

data/lib/facebooker/models/applicationrestrictions.rb

@@ -0,0 +1,10 @@
+module Facebooker
+
+  class ApplicationRestrictions
+    include Model
+    FIELDS = [ :age, :location, :age_distribution, :type ]
+    
+    attr_accessor *FIELDS
+         
+  end
+end

data/lib/facebooker/models/cookie.rb

@@ -0,0 +1,10 @@
+require 'facebooker/model'
+module Facebooker
+  
+  ##
+  # A simple representation of a cookie.
+  class Cookie
+    include Model
+    attr_accessor :uid, :name, :value, :expires, :path
+  end
+end

data/lib/facebooker/models/education_info.rb

@@ -0,0 +1,11 @@
+module Facebooker
+  class EducationInfo
+    class HighschoolInfo
+      include Model
+      attr_accessor :hs1_id, :hs2_id, :grad_year, :hs1_name, :hs2_name
+    end
+    
+    include Model
+    attr_accessor :concentrations, :name, :year, :degree
+  end
+end

data/lib/facebooker/models/event.rb

@@ -0,0 +1,28 @@
+require 'facebooker/model'
+module Facebooker
+  class Event
+    
+    ##
+    # The relationship between a Facebook user and an Event to which he or she has been
+    # invited and may or may not be attending (based on #rsvp_status)
+    class Attendance
+      include Model
+      attr_accessor :eid, :uid, :rsvp_status
+      
+      ##
+      # Get the full, populated Event object which this Attendance is associated with.
+      # First access will query the Facebook API (facebook.events.get).  Subsequent
+      # calls are retrieved from in-memory cache.
+      def event
+        @event ||= Event.from_hash(session.post('facebook.events.get', :eids => [eid]).first)
+      end
+      
+      #TODO: implement user() method
+    end
+    
+    include Model
+    attr_accessor :eid, :pic, :pic_small, :pic_big, :name, :creator, :update_time, :description, :tagline, :venue, :host, :event_type, :nid, :location, :end_time, :start_time, :event_subtype
+
+    id_is :eid
+  end
+end

data/lib/facebooker/models/friend_list.rb

@@ -0,0 +1,16 @@
+require 'facebooker/model'
+module Facebooker
+  ##
+  # A simple representation of a friend list.
+  class FriendList
+    include Model
+    attr_accessor :flid, :name
+    
+    id_is :flid
+
+    # We need this to be an integer, so do the conversion
+    def flid=(f)
+      @flid= ( f.nil? ? nil : f.to_i)
+    end
+  end
+end

data/lib/facebooker/models/group.rb

@@ -0,0 +1,36 @@
+require 'facebooker/model'
+module Facebooker
+  class Group
+    ##
+    # The model of a user's relationship to a group.  Users can occupy different positions within a group (e.g. 'owner')
+    class Membership
+      include Model
+      attr_accessor :position, :gid, :uid
+    end
+    include Model
+    attr_accessor :pic, :pic_small, :pic_big, :name, :creator, :recent_news, :gid, :update_time, :group_subtype, :group_type, :website, :office, :description, :venue, :nid
+    
+    id_is :gid
+    
+    ##
+    # Get the full list of members as populated User objects.  First time fetches group members via Facebook API call.  
+    # Subsequent calls return cached values.
+    # This is a convenience method for getting all of the Membership instances and instantiating User instances for each Membership.
+    def members
+      @members ||= memberships.map do |membership|
+        User.new(membership.uid, session)
+      end
+    end
+    
+    ##
+    # Get a list of Membership instances associated with this Group.  First call retrieves the Membership instances via a Facebook
+    # API call.  Subsequent calls are retrieved from in-memory cache.
+    def memberships
+      @memberships ||= session.post('facebook.groups.getMembers', :gid => gid).map do |hash|
+        Membership.from_hash(hash) do |membership|
+          membership.gid = gid
+        end
+      end
+    end
+  end
+end