facebooker 1.0.31 → 1.0.41

data/lib/facebooker/models/photo.rb

@@ -8,5 +8,12 @@ module Facebooker
                   :story_fbid
 
     id_is :pid
+    
+    #override the generated method for id_is to use a string
+    def pid=(val)
+      @pid = val
+    end
+    
+    alias :id= :pid=
   end
 end

data/lib/facebooker/models/user.rb

@@ -10,7 +10,7 @@ module Facebooker
       include Model
       attr_accessor :message, :time, :status_id
     end
-    FIELDS = [:political, :pic_small, :name, :quotes, :is_app_user, :tv, :profile_update_time, :meeting_sex, :hs_info, :timezone, :relationship_status, :hometown_location, :about_me, :wall_count, :significant_other_id, :pic_big, :music, :work_history, :sex, :religion, :notes_count, :activities, :pic_square, :movies, :has_added_app, :education_history, :birthday, :first_name, :meeting_for, :last_name, :interests, :current_location, :pic, :books, :affiliations, :locale, :profile_url, :proxied_email, :email_hashes, :allowed_restrictions, :pic_with_logo, :pic_big_with_logo, :pic_small_with_logo, :pic_square_with_logo]
+    FIELDS = [:status, :political, :pic_small, :name, :quotes, :is_app_user, :tv, :profile_update_time, :meeting_sex, :hs_info, :timezone, :relationship_status, :hometown_location, :about_me, :wall_count, :significant_other_id, :pic_big, :music, :work_history, :sex, :religion, :notes_count, :activities, :pic_square, :movies, :has_added_app, :education_history, :birthday, :first_name, :meeting_for, :last_name, :interests, :current_location, :pic, :books, :affiliations, :locale, :profile_url, :proxied_email, :email_hashes, :allowed_restrictions, :pic_with_logo, :pic_big_with_logo, :pic_small_with_logo, :pic_square_with_logo]
     STANDARD_FIELDS = [:uid, :first_name, :last_name, :name, :timezone, :birthday, :sex, :affiliations, :locale, :profile_url, :pic_square]
     populating_attr_accessor(*FIELDS)
     attr_reader :affiliations
@@ -69,47 +69,88 @@ module Facebooker
     # Set the list of friends, given an array of User objects.  If the list has been retrieved previously, will not set
     def friends=(list_of_friends,flid=nil)
       @friends_hash ||= {}
-     	flid=cast_to_friend_list_id(flid)
-     	#use __blank instead of nil so that this is cached
-     	cache_key = flid||"__blank"
-     	
+       flid=cast_to_friend_list_id(flid)
+       #use __blank instead of nil so that this is cached
+       cache_key = flid||"__blank"
+
       @friends_hash[cache_key] ||= list_of_friends
     end
     
     def cast_to_friend_list_id(flid)
       case flid
- 	    when String
- 	      list=friend_lists.detect {|f| f.name==flid}
- 	      raise Facebooker::Session::InvalidFriendList unless list
- 	      list.flid
- 	    when FriendList
- 	      flid.flid
- 	    else
- 	      flid
- 	    end
- 	  end
+       when String
+         list=friend_lists.detect {|f| f.name==flid}
+         raise Facebooker::Session::InvalidFriendList unless list
+         list.flid
+       when FriendList
+         flid.flid
+       else
+         flid
+       end
+     end
     ##
     # Retrieve friends
     def friends(flid = nil)
-     	@friends_hash ||= {}
-     	flid=cast_to_friend_list_id(flid)
-      
-     	#use __blank instead of nil so that this is cached
-     	cache_key = flid||"__blank"
-     	options = {:uid=>self.id}
-     	options[:flid] = flid unless flid.nil?
-     	@friends_hash[cache_key] ||= @session.post('facebook.friends.get', options,false).map do |uid|
+       @friends_hash ||= {}
+       flid=cast_to_friend_list_id(flid)
+
+       #use __blank instead of nil so that this is cached
+       cache_key = flid||"__blank"
+       options = {:uid=>self.id}
+       options[:flid] = flid unless flid.nil?
+       @friends_hash[cache_key] ||= @session.post('facebook.friends.get', options,false).map do |uid|
           User.new(uid, @session)
       end
       @friends_hash[cache_key]
     end
+
+    ###
+    # Publish a post into the stream on the user's Wall and News Feed.  This
+    # post also appears in the user's friend's streams.  The +publish_stream+
+    # extended permission must be granted in order to use this method.
+    #
+    # See: http://wiki.developers.facebook.com/index.php/Stream.publish
+    #
+    # +target+ can be the current user or some other user.
+    #
+    # Example:
+    #   # Publish a message to my own wall:
+    #   me.publish_to(me, :message => 'hello world')
+    #
+    #   # Publish to a friend's wall with an action link:
+    #   me.publish_to(my_friend,  :message => 'how are you?', :action_links => [
+    #     :text => 'my website',
+    #     :href => 'http://tenderlovemaking.com/'
+    #   ])
+    def publish_to target, options = {}
+      @session.post('facebook.stream.publish',
+                    :uid        => self.id,
+                    :target_id  => target.id,
+                    :message    => options[:message],
+                    :attachment => Facebooker.json_encode(options[:attachment]),
+                    :action_links => Facebooker.json_encode(options[:action_links])
+                   )
+    end
     
-     def friend_lists    
+    
+    ###
+    # Publish a comment on a post
+    #
+    # See: http://wiki.developers.facebook.com/index.php/Stream.addComment
+    #
+    # +post_id+ the post_id for the post that is being commented on
+    # +comment+ the text of the comment
+    def comment_on(post_id, comment)
+      @session.post('facebook.stream.addComment', {:post_id=>post_id, :comment=>comment})
+    end
+    
+
+     def friend_lists
        @friend_lists ||= @session.post('facebook.friends.getLists').map do |hash|
-         friend_list = FriendList.from_hash(hash)                               
-         friend_list.session = session                                          
-         friend_list                                                            
-       end                                                                      
+         friend_list = FriendList.from_hash(hash)
+         friend_list.session = session
+         friend_list
+       end
      end
     ###
     # Retrieve friends with user info populated
@@ -323,6 +364,12 @@ module Facebooker
       session.post('facebook.users.hasAppPermission',:ext_perm=>ext_perm) == "1"
     end    
     
+    ##
+    # Convenience method to check multiple permissions at once
+    def has_permissions?(ext_perms)
+      ext_perms.all?{|p| has_permission?(p)}
+    end            
+    
     ##
     # Convenience method to send email to the current user
     def send_email(subject, text=nil, fbml=nil)

data/lib/facebooker/parser.rb

@@ -2,34 +2,50 @@ require 'rexml/document'
 require 'facebooker/session'
 module Facebooker
   class Parser
-    
-    module REXMLElementExtensions
-      def text_value
-        self.children.first.to_s.strip
+
+    module REXMLElementExtensions # :nodoc:
+      def content
+        self.text || ''
+      end
+
+      def [] key
+        attributes[key]
+      end
+
+      def text?
+        false
+      end
+    end
+
+    module REXMLTextExtensions # :nodoc:
+      def text?
+        true
       end
     end
-    
+
     ::REXML::Element.__send__(:include, REXMLElementExtensions)
-    
+    ::REXML::Text.__send__(:include, REXMLTextExtensions)
+
     def self.parse(method, data)
       Errors.process(data)
       parser = Parser::PARSERS[method]
-      parser.process(
-        data
-      )
+      raise "Can't find a parser for '#{method}'" unless parser
+      parser.process(data)
     end
-    
+
     def self.array_of(response_element, element_name)
       values_to_return = []
-      response_element.elements.each(element_name) do |element|
+      response_element.children.each do |element|
+        next if element.text?
+        next unless element.name == element_name
         values_to_return << yield(element)
       end
       values_to_return
     end
-    
+
     def self.array_of_text_values(response_element, element_name)
       array_of(response_element, element_name) do |element|
-        element.text_value
+        element.content.strip
       end
     end
 
@@ -38,75 +54,85 @@ module Facebooker
         hashinate(element)
       end
     end
-    
+
     def self.element(name, data)
       data = data.body rescue data # either data or an HTTP response
-      doc = REXML::Document.new(data)
-      doc.elements.each(name) do |element|
-        return element
+      begin
+        xml = Nokogiri::XML(data.strip).at(name)
+        if node = xml.at(name)
+          return node
+        end
+        if xml.root.name == name
+          return xml.root
+        end
+      rescue # Can't parse with Nokogiri
+        doc = REXML::Document.new(data)
+        doc.elements.each(name) do |element|
+          return element
+        end
       end
       raise "Element #{name} not found in #{data}"
     end
-    
+
     def self.hash_or_value_for(element)
-      if element.children.size == 1 && element.children.first.kind_of?(REXML::Text)
-        element.text_value
+      if element.children.size == 1 && element.children.first.text?
+        element.content.strip
       else
         hashinate(element)
       end
     end
-    
+
     def self.hashinate(response_element)
-      response_element.children.reject{|c| c.kind_of? REXML::Text}.inject({}) do |hash, child|
+      response_element.children.reject{|c| c.text? }.inject({}) do |hash, child|
         # If the node hasn't any child, and is not a list, we want empty strings, not empty hashes,
         #   except if attributes['nil'] == true
-        hash[child.name] = 
-        if (child.attributes['nil'] == 'true')
-          nil 
-        elsif (child.children.size == 1 && child.children.first.kind_of?(REXML::Text)) || (child.children.size == 0 && child.attributes['list'] != 'true')
-          anonymous_field_from(child, hash) || child.text_value
-        elsif child.attributes['list'] == 'true'
-          child.children.reject{|c| c.kind_of? REXML::Text}.map { |subchild| hash_or_value_for(subchild)}    
+        hash[child.name] =
+        if (child['nil'] == 'true')
+          nil
+        elsif (child.children.size == 1 && child.children.first.text?) || (child.children.size == 0 && child['list'] != 'true')
+          anonymous_field_from(child, hash) || child.content.strip
+        elsif child['list'] == 'true'
+          child.children.reject{|c| c.text? }.map { |subchild| hash_or_value_for(subchild)}
         else
-          child.children.reject{|c| c.kind_of? REXML::Text}.inject({}) do |subhash, subchild|
+          child.children.reject{|c| c.text? }.inject({}) do |subhash, subchild|
             subhash[subchild.name] = hash_or_value_for(subchild)
             subhash
           end
         end #if (child.attributes)
         hash
-      end #do |hash, child|      
+      end #do |hash, child|
     end
-    
+
     def self.booleanize(response)
       response == "1" ? true : false
     end
-    
+
     def self.anonymous_field_from(child, hash)
       if child.name == 'anon'
-        (hash[child.name] || []) << child.text_value
+        (hash[child.name] || []) << child.content.strip
       end
     end
-    
-  end  
-  
+
+  end
+
   class RevokeAuthorization < Parser#:nodoc:
     def self.process(data)
       booleanize(data)
     end
   end
-  
+
   class CreateToken < Parser#:nodoc:
     def self.process(data)
-      element('auth_createToken_response', data).text_value
+      element('auth_createToken_response', data).content.strip
     end
   end
-  
+
   class RegisterUsers < Parser
     def self.process(data)
       array_of_text_values(element("connect_registerUsers_response", data), "connect_registerUsers_response_elt")
     end
   end
-  
+
   class UnregisterUsers < Parser
     def self.process(data)
       array_of_text_values(element("connect_unregisterUsers_response", data), "connect_unregisterUsers_response_elt")
@@ -115,49 +141,49 @@ module Facebooker
 
   class GetUnconnectedFriendsCount < Parser
     def self.process(data)
-      hash_or_value_for(element("connect_getUnconnectedFriendsCount_response",data)).to_i 
+      hash_or_value_for(element("connect_getUnconnectedFriendsCount_response",data)).to_i
     end
   end
 
   class GetSession < Parser#:nodoc:
-    def self.process(data)      
+    def self.process(data)
       hashinate(element('auth_getSession_response', data))
     end
   end
-  
+
   class GetFriends < Parser#:nodoc:
     def self.process(data)
       array_of_text_values(element('friends_get_response', data), 'uid')
     end
   end
-  
+
   class FriendListsGet < Parser#:nodoc:
     def self.process(data)
       array_of_hashes(element('friends_getLists_response', data), 'friendlist')
     end
   end
- 
+
   class UserInfo < Parser#:nodoc:
     def self.process(data)
       array_of_hashes(element('users_getInfo_response', data), 'user')
     end
   end
-  
+
   class UserStandardInfo < Parser#:nodoc:
     def self.process(data)
       array_of_hashes(element('users_getStandardInfo_response', data), 'standard_user_info')
     end
   end
-  
+
   class GetLoggedInUser < Parser#:nodoc:
     def self.process(data)
-      Integer(element('users_getLoggedInUser_response', data).text_value)
+      Integer(element('users_getLoggedInUser_response', data).content.strip)
     end
   end
 
   class PagesIsAdmin < Parser#:nodoc:
     def self.process(data)
-      element('pages_isAdmin_response', data).text_value == '1'
+      element('pages_isAdmin_response', data).content.strip == '1'
     end
   end
 
@@ -166,22 +192,34 @@ module Facebooker
       array_of_hashes(element('pages_getInfo_response', data), 'page')
     end
   end
-  
+
   class PagesIsFan < Parser#:nodoc:
     def self.process(data)
-      element('pages_isFan_response', data).text_value == '1'
+      element('pages_isFan_response', data).content.strip == '1'
     end
-  end  
+  end
 
   class PublishStoryToUser < Parser#:nodoc:
     def self.process(data)
-      element('feed_publishStoryToUser_response', data).text_value
+      element('feed_publishStoryToUser_response', data).content.strip
     end
   end
 
+  class StreamPublish < Parser#:nodoc:
+    def self.process(data)
+      element('stream_publish_response', data).content.strip
+    end
+  end
+  
+  class StreamAddComment < Parser#:nodoc:
+    def self.process(data)
+      element('stream_addComment_response', data).content.strip
+    end
+  end  
+
   class RegisterTemplateBundle < Parser#:nodoc:
     def self.process(data)
-      element('feed_registerTemplateBundle_response', data).text_value.to_i
+      element('feed_registerTemplateBundle_response', data).content.to_i
     end
   end
 
@@ -193,58 +231,58 @@ module Facebooker
 
   class DeactivateTemplateBundleByID < Parser#:nodoc:
     def self.process(data)
-      element('feed_deactivateTemplateBundleByID_response', data).text_value == '1'
+      element('feed_deactivateTemplateBundleByID_response', data).content.strip == '1'
     end
   end
 
   class PublishUserAction < Parser#:nodoc:
     def self.process(data)
-      element('feed_publishUserAction_response', data).children[1].text_value == "1"
+      element('feed_publishUserAction_response', data).children[1].content.strip == "1"
     end
   end
-  
+
   class PublishActionOfUser < Parser#:nodoc:
     def self.process(data)
-      element('feed_publishActionOfUser_response', data).text_value
+      element('feed_publishActionOfUser_response', data).content.strip
     end
   end
-    
+
   class PublishTemplatizedAction < Parser#:nodoc:
     def self.process(data)
-      element('feed_publishTemplatizedAction_response', data).children[1].text_value
+      element('feed_publishTemplatizedAction_response', data).children[1].content.strip
     end
   end
-  
+
   class SetAppProperties < Parser#:nodoc:
     def self.process(data)
-      element('admin_setAppProperties_response', data).text_value
+      element('admin_setAppProperties_response', data).content.strip
     end
-  end  
-  
+  end
+
   class GetAppProperties < Parser#:nodoc:
     def self.process(data)
-      element('admin_getAppProperties_response', data).text_value
+      element('admin_getAppProperties_response', data).content.strip
     end
   end
-  
+
   class SetRestrictionInfo < Parser#:nodoc:
     def self.process(data)
-      element('admin_setRestrictionInfo_response', data).text_value
+      element('admin_setRestrictionInfo_response', data).content.strip
     end
-  end  
-  
+  end
+
   class GetRestrictionInfo < Parser#:nodoc:
     def self.process(data)
-      element('admin_getRestrictionInfo_response', data).text_value
+      element('admin_getRestrictionInfo_response', data).content.strip
     end
   end
-  
+
   class GetAllocation < Parser#:nodoc:
     def self.process(data)
-      element('admin_getAllocation_response', data).text_value
+      element('admin_getAllocation_response', data).content.strip
     end
   end
-  
+
   class BatchRun < Parser #:nodoc:
     class << self
       def current_batch=(current_batch)
@@ -267,28 +305,28 @@ module Facebooker
       end
     end
   end
-  
+
   class GetAppUsers < Parser#:nodoc:
     def self.process(data)
       array_of_text_values(element('friends_getAppUsers_response', data), 'uid')
     end
   end
-  
+
   class NotificationsGet < Parser#:nodoc:
     def self.process(data)
       hashinate(element('notifications_get_response', data))
     end
   end
-  
+
   class NotificationsSend < Parser#:nodoc:
     def self.process(data)
-      element('notifications_send_response', data).text_value
+      element('notifications_send_response', data).content.strip
     end
-  end 
+  end
 
   class NotificationsSendEmail < Parser#:nodoc:
-    def self.process(data)  
-      element('notifications_sendEmail_response', data).text_value
+    def self.process(data)
+      element('notifications_sendEmail_response', data).content.strip
     end
   end
 
@@ -297,7 +335,7 @@ module Facebooker
       array_of_hashes(element('photos_getTags_response', data), 'photo_tag')
     end
   end
-  
+
   class AddTags < Parser#nodoc:
     def self.process(data)
       element('photos_addTag_response', data)
@@ -309,19 +347,19 @@ module Facebooker
       array_of_hashes(element('photos_get_response', data), 'photo')
     end
   end
-  
+
   class GetAlbums < Parser#nodoc:
     def self.process(data)
       array_of_hashes(element('photos_getAlbums_response', data), 'album')
     end
   end
-  
+
   class CreateAlbum < Parser#:nodoc:
     def self.process(data)
       hashinate(element('photos_createAlbum_response', data))
     end
-  end  
-  
+  end
+
   class UploadPhoto < Parser#:nodoc:
     def self.process(data)
       hashinate(element('photos_upload_response', data))
@@ -333,81 +371,100 @@ module Facebooker
       hashinate(element('video_upload_response', data))
     end
   end
-  
+
   class SendRequest < Parser#:nodoc:
     def self.process(data)
-      element('notifications_sendRequest_response', data).text_value
+      element('notifications_sendRequest_response', data).content.strip
     end
   end
-  
+
   class ProfileFBML < Parser#:nodoc:
     def self.process(data)
-      element('profile_getFBML_response', data).text_value
+      element('profile_getFBML_response', data).content.strip
     end
   end
-  
+
   class ProfileFBMLSet < Parser#:nodoc:
     def self.process(data)
-      element('profile_setFBML_response', data).text_value
+      element('profile_setFBML_response', data).content.strip
     end
   end
-  
+
   class ProfileInfo < Parser#:nodoc:
     def self.process(data)
       hashinate(element('profile_getInfo_response info_fields', data))
     end
   end
-  
+
   class ProfileInfoSet < Parser#:nodoc:
     def self.process(data)
-      element('profile_setInfo_response', data).text_value
+      element('profile_setInfo_response', data).content.strip
     end
   end
-  
+
   class FqlQuery < Parser#nodoc
     def self.process(data)
       root = element('fql_query_response', data)
-      first_child = root.children.reject{|c| c.kind_of?(REXML::Text)}.first
+      first_child = root.children.reject{|c| c.text? }.first
       first_child.nil? ? [] : [first_child.name, array_of_hashes(root, first_child.name)]
     end
   end
-  
+
+  class FqlMultiquery < Parser#nodoc
+    def self.process(data)
+      root = element('fql_multiquery_response', data)
+      root.elements.collect do |elm|
+        [
+         elm.elements[1].text,
+          if elm.elements[2].elements[1].nil?
+            [] 
+          else
+            [
+             elm.elements[2].elements[1].name,
+             array_of_hashes(elm.elements[2], elm.elements[2].elements[1].name)
+            ]
+          end
+        ]
+      end
+    end
+  end
+
   class SetRefHandle < Parser#:nodoc:
     def self.process(data)
-      element('fbml_setRefHandle_response', data).text_value
+      element('fbml_setRefHandle_response', data).content.strip
     end
   end
-  
+
   class RefreshRefURL < Parser#:nodoc:
     def self.process(data)
-      element('fbml_refreshRefUrl_response', data).text_value
+      element('fbml_refreshRefUrl_response', data).content.strip
     end
   end
-  
+
   class RefreshImgSrc < Parser#:nodoc:
     def self.process(data)
-      element('fbml_refreshImgSrc_response', data).text_value
+      element('fbml_refreshImgSrc_response', data).content.strip
     end
   end
-  
+
   class SetCookie < Parser#:nodoc:
     def self.process(data)
-      element('data_setCookie_response', data).text_value
+      element('data_setCookie_response', data).content.strip
     end
   end
-  
+
   class GetCookies < Parser#:nodoc:
     def self.process(data)
       array_of_hashes(element('data_getCookie_response', data), 'cookies')
     end
   end
-  
+
   class EventsGet < Parser#:nodoc:
     def self.process(data)
       array_of_hashes(element('events_get_response', data), 'event')
     end
   end
-  
+
   class GroupGetMembers < Parser#:nodoc:
     def self.process(data)
       root = element('groups_getMembers_response', data)
@@ -417,10 +474,10 @@ module Facebooker
             {:position => position}.merge(:uid => uid)
           end
         end
-      end.flatten      
+      end.flatten
     end
   end
-  
+
   class EventMembersGet < Parser#:nodoc:
     def self.process(data)
       root = element('events_getMembers_response', data)
@@ -433,13 +490,13 @@ module Facebooker
       end.flatten
     end
   end
-  
+
   class GroupsGet < Parser#:nodoc:
     def self.process(data)
       array_of_hashes(element('groups_get_response', data), 'group')
     end
   end
-  
+
   class AreFriends < Parser#:nodoc:
     def self.process(data)
       array_of_hashes(element('friends_areFriends_response', data), 'friend_info').inject({}) do |memo, hash|
@@ -459,40 +516,40 @@ module Facebooker
       end
     end
   end
-  
+
   class SetStatus < Parser
     def self.process(data)
-      element('users_setStatus_response',data).text_value == '1'
+      element('users_setStatus_response',data).content.strip == '1'
     end
   end
-  
+
   class GetPreference < Parser#:nodoc:
     def self.process(data)
-      element('data_getUserPreference_response', data).text_value
+      element('data_getUserPreference_response', data).content.strip
     end
   end
-  
+
   class SetPreference < Parser#:nodoc:
     def self.process(data)
-      element('data_setUserPreference_response', data).text_value
+      element('data_setUserPreference_response', data).content.strip
     end
   end
-    
+
   class UserHasPermission < Parser
     def self.process(data)
-      element('users_hasAppPermission_response', data).text_value
+      element('users_hasAppPermission_response', data).content.strip
     end
-  end  
+  end
 
   class SmsSend < Parser#:nodoc:
     def self.process(data)
-      element('sms_send_response', data).text_value == '0'
+      element('sms_send_response', data).content.strip == '0'
     end
   end
-  
+
   class SmsCanSend < Parser#:nodoc:
     def self.process(data)
-      element('sms_canSend_response', data).text_value
+      element('sms_canSend_response', data).content.strip
     end
   end
 
@@ -521,7 +578,7 @@ module Facebooker
       345 => Facebooker::Session::BlankFeedTitle,
       346 => Facebooker::Session::FeedBodyLengthTooLong,
       347 => Facebooker::Session::InvalidFeedPhotoSource,
-      348 => Facebooker::Session::InvalidFeedPhotoLink,      
+      348 => Facebooker::Session::InvalidFeedPhotoLink,
       330 => Facebooker::Session::FeedMarkupInvalid,
       360 => Facebooker::Session::FeedTitleDataInvalid,
       361 => Facebooker::Session::FeedTitleTemplateInvalid,
@@ -546,7 +603,7 @@ module Facebooker
       end
     end
   end
-  
+
   class Parser
     PARSERS = {
       'facebook.auth.revokeAuthorization' => RevokeAuthorization,
@@ -562,7 +619,7 @@ module Facebooker
       'facebook.users.hasAppPermission' => UserHasPermission,
       'facebook.pages.isAdmin' => PagesIsAdmin,
       'facebook.pages.getInfo' => PagesGetInfo,
-      'facebook.pages.isFan' => PagesIsFan,      
+      'facebook.pages.isFan' => PagesIsFan,
       'facebook.friends.get' => GetFriends,
       'facebook.friends.getLists' => FriendListsGet,
       'facebook.friends.areFriends' => AreFriends,
@@ -593,12 +650,15 @@ module Facebooker
       'facebook.admin.getAllocation' => GetAllocation,
       'facebook.batch.run' => BatchRun,
       'facebook.fql.query' => FqlQuery,
+      'facebook.fql.multiquery' => FqlMultiquery,
       'facebook.photos.get' => GetPhotos,
       'facebook.photos.getAlbums' => GetAlbums,
       'facebook.photos.createAlbum' => CreateAlbum,
       'facebook.photos.getTags' => GetTags,
       'facebook.photos.addTag' => AddTags,
       'facebook.photos.upload' => UploadPhoto,
+      'facebook.stream.publish' => StreamPublish,
+      'facebook.stream.addComment' => StreamAddComment,      
       'facebook.events.get' => EventsGet,
       'facebook.groups.get' => GroupsGet,
       'facebook.events.getMembers' => EventMembersGet,