Class Facebooker::Session
In: lib/facebooker/session.rb
Parent: Object

Methods

Classes and Modules

Class Facebooker::Session::AlbumIsFull
Class Facebooker::Session::BlankFeedTitle
Class Facebooker::Session::CallOutOfOrder
Class Facebooker::Session::ConfigurationMissing
Class Facebooker::Session::Desktop
Class Facebooker::Session::ExtendedPermissionRequired
Class Facebooker::Session::FQLFieldDoesNotExist
Class Facebooker::Session::FQLFunctionDoesNotExist
Class Facebooker::Session::FQLParseError
Class Facebooker::Session::FQLStatementNotIndexable
Class Facebooker::Session::FQLTableDoesNotExist
Class Facebooker::Session::FQLWrongNumberArgumentsPassedToFunction
Class Facebooker::Session::FeedBodyDataInvalid
Class Facebooker::Session::FeedBodyLengthTooLong
Class Facebooker::Session::FeedBodyTemplateInvalid
Class Facebooker::Session::FeedMarkupInvalid
Class Facebooker::Session::FeedPhotosNotRetrieved
Class Facebooker::Session::FeedTargetIdsInvalid
Class Facebooker::Session::FeedTitleDataInvalid
Class Facebooker::Session::FeedTitleTemplateInvalid
Class Facebooker::Session::HostNotAllowed
Class Facebooker::Session::IncorrectSignature
Class Facebooker::Session::InvalidAPIKey
Class Facebooker::Session::InvalidAlbumId
Class Facebooker::Session::InvalidFeedPhotoLink
Class Facebooker::Session::InvalidFeedPhotoSource
Class Facebooker::Session::InvalidFeedTitleLength
Class Facebooker::Session::InvalidFeedTitleLink
Class Facebooker::Session::InvalidFeedTitleName
Class Facebooker::Session::InvalidFriendList
Class Facebooker::Session::MaxRequestsDepleted
Class Facebooker::Session::MissingOrInvalidImageFile
Class Facebooker::Session::MissingOrInvalidParameter
Class Facebooker::Session::PermissionError
Class Facebooker::Session::ReadMailboxExtendedPermissionRequired
Class Facebooker::Session::ServiceUnavailable
Class Facebooker::Session::SessionExpired
Class Facebooker::Session::SignatureTooOld
Class Facebooker::Session::TemplateBundleInvalid
Class Facebooker::Session::TemplateDataMissingRequiredTokens
Class Facebooker::Session::TooManyUnapprovedPhotosPending
Class Facebooker::Session::TooManyUserActionCalls
Class Facebooker::Session::TooManyUserCalls
Class Facebooker::Session::UnknownError
Class Facebooker::Session::UserRegistrationFailed
Class Facebooker::Session::UserUnRegistrationFailed

Constants

API_SERVER_BASE_URL = ENV["FACEBOOKER_API"] == "new" ? "api.new.facebook.com" : "api.facebook.com"
API_PATH_REST = "/restserver.php"
WWW_SERVER_BASE_URL = ENV["FACEBOOKER_API"] == "new" ? "www.new.facebook.com" : "www.facebook.com"
WWW_PATH_LOGIN = "/login.php"
WWW_PATH_ADD = "/add.php"
WWW_PATH_INSTALL = "/install.php"

Attributes

auth_token  [W] 
secret_from_session  [R] 
session_key  [R] 

Public Class methods

[Source]

# File lib/facebooker/session.rb, line 87
    def self.api_key
      extract_key_from_environment(:api) || extract_key_from_configuration_file(:api) rescue report_inability_to_find_key(:api)
    end

[Source]

# File lib/facebooker/session.rb, line 709
    def self.configuration_file_path
      @configuration_file_path || File.expand_path("~/.facebookerrc")
    end

[Source]

# File lib/facebooker/session.rb, line 713
    def self.configuration_file_path=(path)
      @configuration_file_path = path
    end

[Source]

# File lib/facebooker/session.rb, line 80
    def self.create(api_key=nil, secret_key=nil)
      api_key ||= self.api_key
      secret_key ||= self.secret_key
      raise ArgumentError unless !api_key.nil? && !secret_key.nil?
      new(api_key, secret_key)
    end

[Source]

# File lib/facebooker/session.rb, line 95
    def self.current
      Thread.current['facebook_session']
    end

[Source]

# File lib/facebooker/session.rb, line 99
    def self.current=(session)
      Thread.current['facebook_session'] = session
    end

[Source]

# File lib/facebooker/session.rb, line 171
    def initialize(api_key, secret_key)
      @api_key        = api_key
      @secret_key     = secret_key
      @batch_request  = nil
      @session_key    = nil
      @uid            = nil
      @auth_token     = nil
      @secret_from_session = nil
      @expires        = nil
    end

[Source]

# File lib/facebooker/session.rb, line 91
    def self.secret_key
      extract_key_from_environment(:secret) || extract_key_from_configuration_file(:secret) rescue report_inability_to_find_key(:secret)
    end

Public Instance methods

[Source]

# File lib/facebooker/session.rb, line 521
    def active_template_bundles
      post("facebook.feed.getRegisteredTemplateBundles",{},false)
    end

[Source]

# File lib/facebooker/session.rb, line 146
    def add_next_parameters(options)
      opts = []
      opts << "&next=#{CGI.escape(options[:next])}" if options[:next]
      opts << "&next_cancel=#{CGI.escape(options[:next_cancel])}" if options[:next_cancel]
      opts
    end

[Source]

# File lib/facebooker/session.rb, line 469
    def add_tags(pid, x, y, tag_uid = nil, tag_text = nil )
      if [tag_uid, tag_text].all? {|arg| arg.nil?}
        raise ArgumentError, "Must enter a name or string for this tag"        
      end
      @tags = post('facebook.photos.addTag', :pid => pid, :tag_uid => tag_uid, :tag_text => tag_text, :x => x, :y => y )
    end

[Source]

# File lib/facebooker/session.rb, line 620
    def add_to_batch(req,&proc)
      batch_request = BatchRequest.new(req,proc)
      Thread.current[:facebooker_current_batch_queue]<<batch_request
      batch_request
    end

[Source]

# File lib/facebooker/session.rb, line 387
    def admin
      Facebooker::Admin.new(self)
    end

[Source]

# File lib/facebooker/session.rb, line 391
    def application
      Facebooker::Application.new(self)
    end

[Source]

# File lib/facebooker/session.rb, line 186
    def auth_token
      @auth_token ||= post 'facebook.auth.createToken'
    end

Submit the enclosed requests for this session inside a batch

All requests will be sent to Facebook at the end of the block each method inside the block will return a proxy object attempting to access the proxy before the end of the block will yield an exception

For Example:

  facebook_session.batch do
    @send_result = facebook_session.send_notification([12451752],"Woohoo")
    @albums = facebook_session.user.albums
  end
  puts @albums.first.inspect

is valid, however

  facebook_session.batch do
    @send_result = facebook_session.send_notification([12451752],"Woohoo")
    @albums = facebook_session.user.albums
    puts @albums.first.inspect
  end

will raise Facebooker::BatchRequest::UnexecutedRequest

If an exception is raised while processing the result, that exception will be re-raised on the next access to that object or when exception_raised? is called

for example, if the send_notification resulted in TooManyUserCalls being raised, calling

  @send_result.exception_raised?

would re-raise that exception if there was an error retrieving the albums, it would be re-raised when

 @albums.first

is called

[Source]

# File lib/facebooker/session.rb, line 661
    def batch(serial_only=false)
      @batch_request=true
      Thread.current[:facebooker_current_batch_queue]=[]
      yield
      # Set the batch request to false so that post will execute the batch job
      @batch_request=false
      BatchRun.current_batch=Thread.current[:facebooker_current_batch_queue]
      post("facebook.batch.run",:method_feed=>BatchRun.current_batch.map{|q| q.uri}.to_json,:serial_only=>serial_only.to_s)
    ensure
      @batch_request=false
      BatchRun.current_batch=nil
    end

[Source]

# File lib/facebooker/session.rb, line 616
    def batch_request?
      @batch_request
    end

Cancel an event wiki.developers.facebook.com/index.php/Events.cancel E.g:

 @session.cancel_event('100321123', :cancel_message => "It's raining...")
 # => Returns true if all went well

[Source]

# File lib/facebooker/session.rb, line 331
    def cancel_event(eid, options = {})
      result = post('facebook.events.cancel', options.merge(:eid => eid))
      result == '1' ? true : false
    end

Given an array like: [[userid, otheruserid], [yetanotherid, andanotherid]] returns a Hash indicating friendship of those pairs: {[userid, otheruserid] => true, [yetanotherid, andanotherid] => false} if one of the Hash values is nil, it means the facebook platform‘s answer is "I don‘t know"

[Source]

# File lib/facebooker/session.rb, line 405
    def check_friendship(array_of_pairs_of_users)
      uids1 = []
      uids2 = []
      array_of_pairs_of_users.each do |pair|
        uids1 << pair.first
        uids2 << pair.last
      end
      post('facebook.friends.areFriends', :uids1 => uids1.join(','), :uids2 => uids2.join(','))
    end

[Source]

# File lib/facebooker/session.rb, line 133
    def connect_permission_url(permission,options={})
      options = default_login_url_options.merge(options)
      options = add_next_parameters(options)
      options << "&ext_perm=#{permission}"
      "#{Facebooker.connect_permission_url_base}#{options.join}"
    end

Creates an event with the event_info hash and an optional Net::HTTP::MultipartPostFile for the event picture. If ActiveSupport::TimeWithZone is installed (it‘s in Rails > 2.1), and start_time or end_time are given as ActiveSupport::TimeWithZone, then they will be assumed to represent local time for the event. They will automatically be converted to the expected timezone for Facebook, which is PST or PDT depending on when the event occurs. Returns the eid of the newly created event wiki.developers.facebook.com/index.php/Events.create

[Source]

# File lib/facebooker/session.rb, line 302
    def create_event(event_info, multipart_post_file = nil)
      if defined?(ActiveSupport::TimeWithZone) && defined?(ActiveSupport::TimeZone)
        # Facebook expects all event local times to be in Pacific Time, so we need to take the actual local time and 
        # send it to Facebook as if it were Pacific Time converted to Unix epoch timestamp. Very confusing...
        facebook_time = ActiveSupport::TimeZone["Pacific Time (US & Canada)"]
        
        start_time = event_info.delete(:start_time) || event_info.delete('start_time')
        if start_time && start_time.is_a?(ActiveSupport::TimeWithZone)
          event_info['start_time'] = facebook_time.parse(start_time.strftime("%Y-%m-%d %H:%M:%S")).to_i
        else
          event_info['start_time'] = start_time
        end
        
        end_time = event_info.delete(:end_time) || event_info.delete('end_time')
        if end_time && end_time.is_a?(ActiveSupport::TimeWithZone)
          event_info['end_time'] = facebook_time.parse(end_time.strftime("%Y-%m-%d %H:%M:%S")).to_i
        else
          event_info['end_time'] = end_time
        end
      end
      
      post_file('facebook.events.create', :event_info => event_info.to_json, nil => multipart_post_file)
    end

Returns a proxy object for handling calls to the Facebook Data API

[Source]

# File lib/facebooker/session.rb, line 383
    def data
      Facebooker::Data.new(self)
    end

Deactivate a template bundle with Facebook. Returns true if a bundle with the specified id is active and owned by this app. Useful to avoid exceeding the 100 templates/app limit.

[Source]

# File lib/facebooker/session.rb, line 517
    def deactivate_template_bundle_by_id(template_bundle_id)
      post("facebook.feed.deactivateTemplateBundleByID", {:template_bundle_id => template_bundle_id.to_s}, false)
    end

[Source]

# File lib/facebooker/session.rb, line 167
    def default_login_url_options
      {}
    end

[Source]

# File lib/facebooker/session.rb, line 336
    def event_members(eid)
      @members ||= {}
      @members[eid] ||= post('facebook.events.getMembers', :eid => eid) do |response|
        response.map do |attendee_hash|
          Event::Attendance.from_hash(attendee_hash)
        end
      end
    end

This one has so many parameters, a Hash seemed cleaner than a long param list. Options can be: :uid => Filter by events associated with a user with this uid :eids => Filter by this list of event ids. This is a comma-separated list of eids. :start_time => Filter with this UTC as lower bound. A missing or zero parameter indicates no lower bound. (Time or Integer) :end_time => Filter with this UTC as upper bound. A missing or zero parameter indicates no upper bound. (Time or Integer) :rsvp_status => Filter by this RSVP status.

[Source]

# File lib/facebooker/session.rb, line 287
    def events(options = {})
      @events ||= {}
      @events[options.to_s] ||= post('facebook.events.get', options) do |response|
        response.map do |hash|
          Event.from_hash(hash)
        end
      end
    end

[Source]

# File lib/facebooker/session.rb, line 194
    def expired?
      @expires.nil? || (!infinite? && Time.at(@expires) <= Time.now)
    end

[Source]

# File lib/facebooker/session.rb, line 590
    def fields_to_serialize
      %w(session_key uid expires secret_from_session auth_token api_key secret_key)
    end

[Source]

# File lib/facebooker/session.rb, line 218
    def fql_build_object(type, hash)
      case type
      when 'user'
        user = User.new
        user.session = self
        user.populate_from_hash!(hash)
        user
      when 'photo'
        Photo.from_hash(hash)
      when 'album'
        Album.from_hash(hash)
      when 'page'
        Page.from_hash(hash)
      when 'page_admin'
        Page.from_hash(hash)
      when 'group'
        Group.from_hash(hash)
      when 'event'
        Event.from_hash(hash)
      when 'event_member'
        Event::Attendance.from_hash(hash)
      else
        hash
      end
    end

[Source]

# File lib/facebooker/session.rb, line 257
    def fql_multiquery(queries, format = 'XML')
      results = {}
      post('facebook.fql.multiquery', :queries => queries.to_json, :format => format) do |responses|
        responses.each do |response|
          name = response.shift
          response = response.shift
          type = response.shift
          value = [] 
          unless type.nil?
            value = response.shift.map do |hash|
              fql_build_object(type, hash)
            end
          end
          results[name] = value
        end
      end
      results
    end

[Source]

# File lib/facebooker/session.rb, line 244
    def fql_query(query, format = 'XML')
      post('facebook.fql.query', :query => query, :format => format) do |response|
        type = response.shift
        if type.nil?
          []
        else
          response.shift.map do |hash|
            fql_build_object(type, hash)
          end
        end
      end
    end

[Source]

# File lib/facebooker/session.rb, line 442
    def get_albums(aids)
      @albums = post('facebook.photos.getAlbums', :aids => aids) do |response|
        response.map do |hash|        
          Album.from_hash(hash)
        end
      end
    end

pulls comment list for a given XID

[Source]

# File lib/facebooker/session.rb, line 434
    def get_comments(xid)
      @comments = post('facebook.comments.get', :xid => xid) do |response|
        response.map do |hash|
          Comment.from_hash(hash)
        end
      end
    end

[Source]

# File lib/facebooker/session.rb, line 415
    def get_photos(pids = nil, subj_id = nil,  aid = nil)
      if [subj_id, pids, aid].all? {|arg| arg.nil?}
        raise ArgumentError, "Can't get a photo without a picture, album or subject ID" 
      end
      # We have to normalize params orherwise FB complain about signature
      params = {:pids => pids, :subj_id => subj_id, :aid => aid}.delete_if { |k,v| v.nil? }
      @photos = post('facebook.photos.get', params ) do |response|
        response.map do |hash|
          Photo.from_hash(hash)
        end
      end
    end

Retrieve a viewer‘s facebook stream See wiki.developers.facebook.com/index.php/Stream.get for options

[Source]

# File lib/facebooker/session.rb, line 454
    def get_stream(viewer_id, options = {})

      @stream = post('facebook.stream.get', prepare_get_stream_options(viewer_id, options), true) do |response|
        response
      end
    end

[Source]

# File lib/facebooker/session.rb, line 461
    def get_tags(pids)
      @tags = post('facebook.photos.getTags', :pids => pids)  do |response|
        response.map do |hash|
          Tag.from_hash(hash)
        end
      end
    end

[Source]

# File lib/facebooker/session.rb, line 190
    def infinite?
      @expires == 0
    end

[Source]

# File lib/facebooker/session.rb, line 108
    def install_url(options={})
      "#{Facebooker.install_url_base}#{install_url_optional_parameters(options)}"
    end

[Source]

# File lib/facebooker/session.rb, line 140
    def install_url_optional_parameters(options)
      optional_parameters = []      
      optional_parameters += add_next_parameters(options)
      optional_parameters.join
    end

[Source]

# File lib/facebooker/session.rb, line 582
    def instance_variable_set_value(field, value)
      self.instance_variable_set("@#{field}", value)
    end

[Source]

# File lib/facebooker/session.rb, line 586
    def instance_variable_value(field)
      self.instance_variable_get("@#{field}")
    end

Takes page_id and uid, returns true if uid is a fan of the page_id

[Source]

# File lib/facebooker/session.rb, line 368
    def is_fan(page_id, uid)
      puts "Deprecated. Use Page#user_is_fan? instead"
      Page.new(page_id).user_is_fan?(uid)
    end

[Source]

# File lib/facebooker/session.rb, line 103
    def login_url(options={})
      options = default_login_url_options.merge(options)
      "#{Facebooker.login_url_base}#{login_url_optional_parameters(options)}"
    end

[Source]

# File lib/facebooker/session.rb, line 153
    def login_url_optional_parameters(options)
      # It is important that unused options are omitted as stuff like &canvas=false will still display the canvas. 
      optional_parameters = []
      optional_parameters += add_next_parameters(options)
      optional_parameters << "&skipcookie=true" if options[:skip_cookie]
      optional_parameters << "&hide_checkbox=true" if options[:hide_checkbox]
      optional_parameters << "&canvas=true" if options[:canvas]
      optional_parameters << "&fbconnect=true" if options[:fbconnect]
      optional_parameters << "&return_session=true" if options[:return_session]
      optional_parameters << "&session_key_only=true" if options[:session_key_only]
      optional_parameters << "&req_perms=#{options[:req_perms]}" if options[:req_perms]
      optional_parameters.join
    end

[Source]

# File lib/facebooker/session.rb, line 395
    def mobile
      Facebooker::Mobile.new(self)
    end

[Source]

# File lib/facebooker/session.rb, line 357
    def pages(options = {})
      raise ArgumentError, 'fields option is mandatory' unless options.has_key?(:fields)
      @pages ||= {}
      @pages[options] ||= post('facebook.pages.getInfo', options) do |response|
        response.map do |hash|
          Page.from_hash(hash)
        end
      end
    end

The url to get user to approve extended permissions wiki.developers.facebook.com/index.php/Extended_permission

permissions:

  • email
  • offline_access
  • status_update
  • photo_upload
  • video_upload
  • create_listing
  • create_event
  • rsvp_event
  • sms
  • read_mailbox

[Source]

# File lib/facebooker/session.rb, line 126
    def permission_url(permission,options={})
      options = default_login_url_options.merge(options)
      options = add_next_parameters(options)
      options << "&ext_perm=#{permission}"
      "#{Facebooker.permission_url_base}#{options.join}"
    end

[Source]

# File lib/facebooker/session.rb, line 687
    def post(method, params = {}, use_session_key = true, &proc)
      if batch_request? or Facebooker::Logging.skip_api_logging
        post_without_logging(method, params, use_session_key, &proc)
      else
        Logging.log_fb_api(method, params) do
          post_without_logging(method, params, use_session_key, &proc)
        end
      end
    end

[Source]

# File lib/facebooker/session.rb, line 697
    def post_file(method, params = {})
      base = params.delete(:base)
      Logging.log_fb_api(method, params) do
        add_facebook_params(params, method)
        @session_key && params[:session_key] ||= @session_key unless params[:uid]
        service.post_file(params.merge(:base => base, :sig => signature_for(params.reject{|key, value| key.nil?})))
      end
    end

[Source]

# File lib/facebooker/session.rb, line 674
    def post_without_logging(method, params = {}, use_session_key = true, &proc)
      add_facebook_params(params, method)
      use_session_key && @session_key && params[:session_key] ||= @session_key
      final_params=params.merge(:sig => signature_for(params))
      if batch_request?
        add_to_batch(final_params,&proc)
      else
        result = service.post(final_params)
        result = yield result if block_given?
        result
      end
    end

publish a previously rendered template bundle see wiki.developers.facebook.com/index.php/Feed.publishUserAction

[Source]

# File lib/facebooker/session.rb, line 529
    def publish_user_action(bundle_id,data={},target_ids=nil,body_general=nil,story_size=nil)
      parameters={:template_bundle_id=>bundle_id,:template_data=>data.to_json}
      parameters[:target_ids] = target_ids unless target_ids.blank?
      parameters[:body_general] = body_general unless body_general.blank?
      parameters[:story_size] = story_size unless story_size.nil?
      post("facebook.feed.publishUserAction", parameters)
    end

Register a template bundle with Facebook. returns the template id to use to send using this template

[Source]

# File lib/facebooker/session.rb, line 493
    def register_template_bundle(one_line_story_templates,short_story_templates=nil,full_story_template=nil, action_links=nil)
      templates = ensure_array(one_line_story_templates)
      parameters = {:one_line_story_templates => templates.to_json}
      
      unless action_links.blank?
        parameters[:action_links] = action_links.to_json
      end
      
      unless short_story_templates.blank?
        templates = ensure_array(short_story_templates)
        parameters[:short_story_templates] = templates.to_json
      end
      
      unless full_story_template.blank?
        parameters[:full_story_template] = full_story_template.to_json
      end
      
      post("facebook.feed.registerTemplateBundle", parameters, false)
    end

remove a comment from a given xid stream with comment_id

[Source]

# File lib/facebooker/session.rb, line 429
    def remove_comment(xid,comment_id)
      post('facebook.comments.remove', :xid=>xid, :comment_id =>comment_id)
    end

[Source]

# File lib/facebooker/session.rb, line 182
    def secret_for_method(method_name)
      @secret_key
    end

[Source]

# File lib/facebooker/session.rb, line 202
    def secure!(args = {})
      response = post 'facebook.auth.getSession', :auth_token => auth_token, :generate_session_secret => args[:generate_session_secret] ? "1" : "0"
      secure_with!(response['session_key'], response['uid'], response['expires'], response['secret'])
    end

[Source]

# File lib/facebooker/session.rb, line 211
    def secure_with!(session_key, uid = nil, expires = nil, secret_from_session = nil)
      @session_key = session_key
      @uid = uid ? Integer(uid) : post('facebook.users.getLoggedInUser', :session_key => session_key)
      @expires = expires ? Integer(expires) : 0
      @secret_from_session = secret_from_session
    end

[Source]

# File lib/facebooker/session.rb, line 207
    def secure_with_session_secret!
      self.secure!(:generate_session_secret => true)
    end

[Source]

# File lib/facebooker/session.rb, line 198
    def secured?
      !@session_key.nil? && !expired?
    end

Send email to as many as 100 users at a time

[Source]

# File lib/facebooker/session.rb, line 555
    def send_email(user_ids, subject, text, fbml = nil)       
      user_ids = Array(user_ids)
      params = {:fbml => fbml, :recipients => user_ids.map{ |id| User.cast_to_facebook_id(id)}.join(','), :text => text, :subject => subject} 
      post 'facebook.notifications.sendEmail', params, false
    end

[Source]

# File lib/facebooker/session.rb, line 476
    def send_notification(user_ids, fbml, email_fbml = nil)
      params = {:notification => fbml, :to_ids => user_ids.map{ |id| User.cast_to_facebook_id(id)}.join(',')}
      if email_fbml
        params[:email] = email_fbml
      end
      params[:type]="user_to_user"
      # if there is no uid, this is an announcement
      unless uid?
        params[:type]="app_to_user"
      end

      post 'facebook.notifications.send', params,uid?
    end

Returns a proxy object for handling calls to Facebook cached items such as images and FBML ref handles

[Source]

# File lib/facebooker/session.rb, line 377
    def server_cache
      Facebooker::ServerCache.new(self)
    end

Only serialize the bare minimum to recreate the session.

[Source]

# File lib/facebooker/session.rb, line 572
    def to_yaml( opts = {} )
      YAML::quick_emit(self.object_id, opts) do |out|
        out.map(taguri) do |map|
          fields_to_serialize.each do |field|
            map.add(field, instance_variable_value(field))
          end
        end
      end
    end

Upload strings in native locale to facebook for translations.

e.g. facebook_session.upload_native_strings([:text => "Welcome {user}", :description => "Welcome message to currently logged in user."]) returns the number of strings uploaded

See wiki.developers.facebook.com/index.php/Intl.uploadNativeStrings for method options

[Source]

# File lib/facebooker/session.rb, line 545
    def upload_native_strings(native_strings)
      raise ArgumentError, "You must provide strings to upload" if native_strings.nil?

      post('facebook.intl.uploadNativeStrings', :native_strings => Facebooker.json_encode(native_strings)) do |response|
        response
      end
    end

[Source]

# File lib/facebooker/session.rb, line 276
    def user
      @user ||= User.new(uid, self)
    end

[Source]

# File lib/facebooker/session.rb, line 351
    def users(user_ids, fields=[])
      post("facebook.users.getInfo",:uids=>user_ids.join(","),:fields=>User.user_fields(fields)) do |users|
        users.map { |u| User.new(u)}
      end
    end

[Source]

# File lib/facebooker/session.rb, line 345
    def users_standard(user_ids, fields=[])
      post("facebook.users.getStandardInfo",:uids=>user_ids.join(","),:fields=>User.standard_fields(fields)) do |users|
        users.map { |u| User.new(u)}
      end
    end

[Validate]