Class: Facebooker::Session

Inherits:
Object
  • Object
show all
Defined in:
lib/facebooker/session.rb

Direct Known Subclasses

CanvasSession, MockSession, Desktop

Defined Under Namespace

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

Constant Summary collapse

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"

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(api_key, secret_key) ⇒ Session

Returns a new instance of Session.



166
167
168
169
170
171
172
173
174
175
 
# File 'lib/facebooker/session.rb', line 166

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

Instance Attribute Details

#auth_token ⇒ Object 



181
182
183
 
# File 'lib/facebooker/session.rb', line 181

def auth_token
  @auth_token ||= post 'facebook.auth.createToken'
end

#secret_from_session ⇒ Object (readonly)

Returns the value of attribute secret_from_session.



76
77
78
 
# File 'lib/facebooker/session.rb', line 76

def secret_from_session
  @secret_from_session
end

#session_key ⇒ Object (readonly)

Returns the value of attribute session_key.



75
76
77
 
# File 'lib/facebooker/session.rb', line 75

def session_key
  @session_key
end

Class Method Details

.api_key ⇒ Object 



85
86
87
 
# File 'lib/facebooker/session.rb', line 85

def self.api_key
  extract_key_from_environment(:api) || extract_key_from_configuration_file(:api) rescue report_inability_to_find_key(:api)
end

.configuration_file_path ⇒ Object 



628
629
630
 
# File 'lib/facebooker/session.rb', line 628

def self.configuration_file_path
  @configuration_file_path || File.expand_path("~/.facebookerrc")
end

.configuration_file_path=(path) ⇒ Object 



632
633
634
 
# File 'lib/facebooker/session.rb', line 632

def self.configuration_file_path=(path)
  @configuration_file_path = path
end

.create(api_key = nil, secret_key = nil) ⇒ Object

Raises:

  • (ArgumentError) 


78
79
80
81
82
83
 
# File 'lib/facebooker/session.rb', line 78

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

.current ⇒ Object 



93
94
95
 
# File 'lib/facebooker/session.rb', line 93

def self.current
  Thread.current['facebook_session']
end

.current=(session) ⇒ Object 



97
98
99
 
# File 'lib/facebooker/session.rb', line 97

def self.current=(session)
  Thread.current['facebook_session'] = session
end

.secret_key ⇒ Object 



89
90
91
 
# File 'lib/facebooker/session.rb', line 89

def self.secret_key
  extract_key_from_environment(:secret) || extract_key_from_configuration_file(:secret) rescue report_inability_to_find_key(:secret)
end

Instance Method Details

#active_template_bundles ⇒ Object 



455
456
457
 
# File 'lib/facebooker/session.rb', line 455

def active_template_bundles
  post("facebook.feed.getRegisteredTemplateBundles",{},false)
end

#add_next_parameters(options) ⇒ Object 



143
144
145
146
147
148
 
# File 'lib/facebooker/session.rb', line 143

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

#add_tags(pid, x, y, tag_uid = nil, tag_text = nil) ⇒ Object 



403
404
405
406
407
408
 
# File 'lib/facebooker/session.rb', line 403

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

#add_to_batch(req, &proc) ⇒ Object 



539
540
541
542
543
 
# File 'lib/facebooker/session.rb', line 539

def add_to_batch(req,&proc)
  batch_request = BatchRequest.new(req,proc)
  Thread.current[:facebooker_current_batch_queue]<<batch_request
  batch_request
end

#admin ⇒ Object 



350
351
352
 
# File 'lib/facebooker/session.rb', line 350

def admin
  Facebooker::Admin.new(self)
end

#batch(serial_only = false) ⇒ Object

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



580
581
582
583
584
585
586
587
588
589
590
591
 
# File 'lib/facebooker/session.rb', line 580

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

#batch_request? ⇒ Boolean

Returns:

  • (Boolean) 


535
536
537
 
# File 'lib/facebooker/session.rb', line 535

def batch_request?
  @batch_request
end

#cancel_event(eid, options = {}) ⇒ Object

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



295
296
297
298
 
# File 'lib/facebooker/session.rb', line 295

def cancel_event(eid, options = {})
  result = post('facebook.events.cancel', options.merge(:eid => eid))
  result == '1' ? true : false
end

#check_friendship(array_of_pairs_of_users) ⇒ Object

Given an array like:

[userid, otheruserid], [yetanotherid, andanotherid]

returns a Hash indicating friendship of those pairs: 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”



364
365
366
367
368
369
370
371
372
 
# File 'lib/facebooker/session.rb', line 364

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

#connect_permission_url(permission, options = {}) ⇒ Object 



130
131
132
133
134
135
 
# File 'lib/facebooker/session.rb', line 130

def connect_permission_url(permission,options={})
  options = .merge(options)
  options = add_next_parameters(options)
  options << "&ext_perm=#{permission}"
  "#{Facebooker.connect_permission_url_base}#{options.join}"
end

#create_event(event_info, multipart_post_file = nil) ⇒ Object

Creates an event with the event_info hash and an optional Net::HTTP::MultipartPostFile for the event picture Returns the eid of the newly created event wiki.developers.facebook.com/index.php/Events.create



286
287
288
 
# File 'lib/facebooker/session.rb', line 286

def create_event(event_info, multipart_post_file = nil)
  post_file('facebook.events.create', :event_info => event_info.to_json, nil => multipart_post_file)
end

#data ⇒ Object

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



346
347
348
 
# File 'lib/facebooker/session.rb', line 346

def data
  Facebooker::Data.new(self)
end

#deactivate_template_bundle_by_id(template_bundle_id) ⇒ Object

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.



451
452
453
 
# File 'lib/facebooker/session.rb', line 451

def deactivate_template_bundle_by_id(template_bundle_id)
  post("facebook.feed.deactivateTemplateBundleByID", {:template_bundle_id => template_bundle_id.to_s}, false)
end

#default_login_url_options ⇒ Object 



162
163
164
 
# File 'lib/facebooker/session.rb', line 162

def 
  {}
end

#event_members(eid) ⇒ Object 



300
301
302
303
304
305
306
 
# File 'lib/facebooker/session.rb', line 300

def event_members(eid)
  @members ||= post('facebook.events.getMembers', :eid => eid) do |response|
    response.map do |attendee_hash|
      Event::Attendance.from_hash(attendee_hash)
    end
  end
end

#events(options = {}) ⇒ Object

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.



275
276
277
278
279
280
281
 
# File 'lib/facebooker/session.rb', line 275

def events(options = {})
  @events ||= post('facebook.events.get', options) do |response|
    response.map do |hash|
      Event.from_hash(hash)
    end
  end
end

#expired? ⇒ Boolean

Returns:

  • (Boolean) 


189
190
191
 
# File 'lib/facebooker/session.rb', line 189

def expired?
  @expires.nil? || (!infinite? && Time.at(@expires) <= Time.now)
end

#fields_to_serialize ⇒ Object 



509
510
511
 
# File 'lib/facebooker/session.rb', line 509

def fields_to_serialize
  %w(session_key uid expires secret_from_session auth_token api_key secret_key)
end

#fql_build_object(type, hash) ⇒ Object 



213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/facebooker/session.rb', line 213

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 'page'
    Page.from_hash(hash)
  when 'page_admin'
    Page.from_hash(hash)
  when 'group'
    Group.from_hash(hash)
  when 'event_member'
    Event::Attendance.from_hash(hash)
  else
    hash
  end
end

#fql_multiquery(queries, format = 'XML') ⇒ Object 



245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
 
# File 'lib/facebooker/session.rb', line 245

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

#fql_query(query, format = 'XML') ⇒ Object 



235
236
237
238
239
240
241
242
243
 
# File 'lib/facebooker/session.rb', line 235

def fql_query(query, format = 'XML')
  post('facebook.fql.query', :query => query, :format => format) do |response|
    type = response.shift
    return [] if type.nil?
    response.shift.map do |hash|
      fql_build_object(type, hash)
    end
  end
end

#get_albums(aids) ⇒ Object 



387
388
389
390
391
392
393
 
# File 'lib/facebooker/session.rb', line 387

def get_albums(aids)
  @albums = post('facebook.photos.getAlbums', :aids => aids) do |response|
    response.map do |hash|        
      Album.from_hash(hash)
    end
  end
end

#get_photos(pids = nil, subj_id = nil, aid = nil) ⇒ Object 



374
375
376
377
378
379
380
381
382
383
384
385
 
# File 'lib/facebooker/session.rb', line 374

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

#get_tags(pids) ⇒ Object 



395
396
397
398
399
400
401
 
# File 'lib/facebooker/session.rb', line 395

def get_tags(pids)
  @tags = post('facebook.photos.getTags', :pids => pids)  do |response|
    response.map do |hash|
      Tag.from_hash(hash)
    end
  end
end

#infinite? ⇒ Boolean

Returns:

  • (Boolean) 


185
186
187
 
# File 'lib/facebooker/session.rb', line 185

def infinite?
  @expires == 0
end

#install_url(options = {}) ⇒ Object 



106
107
108
 
# File 'lib/facebooker/session.rb', line 106

def install_url(options={})
  "#{Facebooker.install_url_base}#{install_url_optional_parameters(options)}"
end

#install_url_optional_parameters(options) ⇒ Object 



137
138
139
140
141
 
# File 'lib/facebooker/session.rb', line 137

def install_url_optional_parameters(options)
  optional_parameters = []      
  optional_parameters += add_next_parameters(options)
  optional_parameters.join
end

#instance_variable_set_value(field, value) ⇒ Object 



501
502
503
 
# File 'lib/facebooker/session.rb', line 501

def instance_variable_set_value(field, value)
  self.instance_variable_set("@#{field}", value)
end

#instance_variable_value(field) ⇒ Object 



505
506
507
 
# File 'lib/facebooker/session.rb', line 505

def instance_variable_value(field)
  self.instance_variable_get("@#{field}")
end

#is_fan(page_id, uid) ⇒ Object

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



331
332
333
334
 
# File 'lib/facebooker/session.rb', line 331

def is_fan(page_id, uid)
  puts "Deprecated. Use Page#user_is_fan? instead"
  Page.new(page_id).user_is_fan?(uid)
end

#login_url(options = {}) ⇒ Object 



101
102
103
104
 
# File 'lib/facebooker/session.rb', line 101

def (options={})
  options = .merge(options)
  "#{Facebooker.}#{(options)}"
end

#login_url_optional_parameters(options) ⇒ Object 



150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/facebooker/session.rb', line 150

def (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 << "&req_perms=#{options[:req_perms]}" if options[:req_perms]
  optional_parameters.join
end

#marshal_dump ⇒ Object

Only serialize the bare minimum to recreate the session.



486
487
488
 
# File 'lib/facebooker/session.rb', line 486

def marshal_dump#:nodoc:
  fields_to_serialize.map{|field| instance_variable_value(field)}
end

#marshal_load(variables) ⇒ Object

Only serialize the bare minimum to recreate the session.



481
482
483
 
# File 'lib/facebooker/session.rb', line 481

def marshal_load(variables)#:nodoc:
  fields_to_serialize.each_with_index{|field, index| instance_variable_set_value(field, variables[index])}
end

#mobile ⇒ Object 



354
355
356
 
# File 'lib/facebooker/session.rb', line 354

def mobile
  Facebooker::Mobile.new(self)
end

#pages(options = {}) ⇒ Object

Raises:

  • (ArgumentError) 


320
321
322
323
324
325
326
327
328
 
# File 'lib/facebooker/session.rb', line 320

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

#permission_url(permission, options = {}) ⇒ Object

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



123
124
125
126
127
128
 
# File 'lib/facebooker/session.rb', line 123

def permission_url(permission,options={})
  options = .merge(options)
  options = add_next_parameters(options)
  options << "&ext_perm=#{permission}"
  "#{Facebooker.permission_url_base}#{options.join}"
end

#post(method, params = {}, use_session_key = true, &proc) ⇒ Object 



606
607
608
609
610
611
612
613
614
 
# File 'lib/facebooker/session.rb', line 606

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

#post_file(method, params = {}) ⇒ Object 



616
617
618
619
620
621
622
623
 
# File 'lib/facebooker/session.rb', line 616

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

#post_without_logging(method, params = {}, use_session_key = true, &proc) ⇒ Object 



593
594
595
596
597
598
599
600
601
602
603
604
 
# File 'lib/facebooker/session.rb', line 593

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_user_action(bundle_id, data = {}, target_ids = nil, body_general = nil, story_size = nil) ⇒ Object

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



463
464
465
466
467
468
469
 
# File 'lib/facebooker/session.rb', line 463

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_template_bundle(one_line_story_templates, short_story_templates = nil, full_story_template = nil, action_links = nil) ⇒ Object

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



427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
 
# File 'lib/facebooker/session.rb', line 427

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

#secret_for_method(method_name) ⇒ Object 



177
178
179
 
# File 'lib/facebooker/session.rb', line 177

def secret_for_method(method_name)
  @secret_key
end

#secure!(args = {}) ⇒ Object 



197
198
199
200
 
# File 'lib/facebooker/session.rb', line 197

def secure!(args = {})
  response = post 'facebook.auth.getSession', :auth_token => auth_token, :generate_session_secret => args[:generate_session_secret]
  secure_with!(response['session_key'], response['uid'], response['expires'], response['secret'])
end

#secure_with!(session_key, uid = nil, expires = nil, secret_from_session = nil) ⇒ Object 



206
207
208
209
210
211
 
# File 'lib/facebooker/session.rb', line 206

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 = Integer(expires)
  @secret_from_session = secret_from_session
end

#secure_with_session_secret! ⇒ Object 



202
203
204
 
# File 'lib/facebooker/session.rb', line 202

def secure_with_session_secret!
  self.secure!(:generate_session_secret => "1")
end

#secured? ⇒ Boolean

Returns:

  • (Boolean) 


193
194
195
 
# File 'lib/facebooker/session.rb', line 193

def secured?
  !@session_key.nil? && !expired?
end

#send_email(user_ids, subject, text, fbml = nil) ⇒ Object

Send email to as many as 100 users at a time



474
475
476
477
478
 
# File 'lib/facebooker/session.rb', line 474

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
end

#send_notification(user_ids, fbml, email_fbml = nil) ⇒ Object 



410
411
412
413
414
415
416
417
418
419
420
421
422
 
# File 'lib/facebooker/session.rb', line 410

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

#server_cache ⇒ Object

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



340
341
342
 
# File 'lib/facebooker/session.rb', line 340

def server_cache
  Facebooker::ServerCache.new(self)
end

#to_yaml(opts = {}) ⇒ Object

Only serialize the bare minimum to recreate the session.



491
492
493
494
495
496
497
498
499
 
# File 'lib/facebooker/session.rb', line 491

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

#user ⇒ Object 



264
265
266
 
# File 'lib/facebooker/session.rb', line 264

def user
  @user ||= User.new(uid, self)
end

#users(user_ids, fields = []) ⇒ Object 



314
315
316
317
318
 
# File 'lib/facebooker/session.rb', line 314

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

#users_standard(user_ids, fields = []) ⇒ Object 



308
309
310
311
312
 
# File 'lib/facebooker/session.rb', line 308

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