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, ReadMailboxExtendedPermissionRequired, 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.



170
171
172
173
174
175
176
177
178
179
# File 'lib/facebooker/session.rb', line 170

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_tokenObject



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

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

#secret_from_sessionObject (readonly)

Returns the value of attribute secret_from_session.



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

def secret_from_session
  @secret_from_session
end

#session_keyObject (readonly)

Returns the value of attribute session_key.



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

def session_key
  @session_key
end

Class Method Details

.api_keyObject



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

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_pathObject



693
694
695
# File 'lib/facebooker/session.rb', line 693

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

.configuration_file_path=(path) ⇒ Object



697
698
699
# File 'lib/facebooker/session.rb', line 697

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

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

Raises:

  • (ArgumentError)


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

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

.currentObject



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

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

.current=(session) ⇒ Object



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

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

.secret_keyObject



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

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_bundlesObject



520
521
522
# File 'lib/facebooker/session.rb', line 520

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

#add_next_parameters(options) ⇒ Object



145
146
147
148
149
150
# File 'lib/facebooker/session.rb', line 145

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



468
469
470
471
472
473
# File 'lib/facebooker/session.rb', line 468

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



604
605
606
607
608
# File 'lib/facebooker/session.rb', line 604

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

#adminObject



386
387
388
# File 'lib/facebooker/session.rb', line 386

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

#applicationObject



390
391
392
# File 'lib/facebooker/session.rb', line 390

def application
  Facebooker::Application.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



645
646
647
648
649
650
651
652
653
654
655
656
# File 'lib/facebooker/session.rb', line 645

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)


600
601
602
# File 'lib/facebooker/session.rb', line 600

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


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

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”



404
405
406
407
408
409
410
411
412
# File 'lib/facebooker/session.rb', line 404

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



132
133
134
135
136
137
# File 'lib/facebooker/session.rb', line 132

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. 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



301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
# File 'lib/facebooker/session.rb', line 301

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

#dataObject

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



382
383
384
# File 'lib/facebooker/session.rb', line 382

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.



516
517
518
# File 'lib/facebooker/session.rb', line 516

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_optionsObject



166
167
168
# File 'lib/facebooker/session.rb', line 166

def 
  {}
end

#event_members(eid) ⇒ Object



335
336
337
338
339
340
341
342
# File 'lib/facebooker/session.rb', line 335

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

#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.



286
287
288
289
290
291
292
293
# File 'lib/facebooker/session.rb', line 286

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

#expired?Boolean

Returns:

  • (Boolean)


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

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

#fields_to_serializeObject



574
575
576
# File 'lib/facebooker/session.rb', line 574

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



217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
# File 'lib/facebooker/session.rb', line 217

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

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



256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
# File 'lib/facebooker/session.rb', line 256

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



243
244
245
246
247
248
249
250
251
252
253
254
# File 'lib/facebooker/session.rb', line 243

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

#get_albums(aids) ⇒ Object



441
442
443
444
445
446
447
# File 'lib/facebooker/session.rb', line 441

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_comments(xid) ⇒ Object

pulls comment list for a given XID



433
434
435
436
437
438
439
# File 'lib/facebooker/session.rb', line 433

def get_comments(xid)
  @comments = post('facebook.comments.get', :xid => xid) do |response|
    response.map do |hash|
      Comment.from_hash(hash)
    end
  end
end

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



414
415
416
417
418
419
420
421
422
423
424
425
# File 'lib/facebooker/session.rb', line 414

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_stream(viewer_id, options = {}) ⇒ Object

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



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

def get_stream(viewer_id, options = {})

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

#get_tags(pids) ⇒ Object



460
461
462
463
464
465
466
# File 'lib/facebooker/session.rb', line 460

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)


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

def infinite?
  @expires == 0
end

#install_url(options = {}) ⇒ Object



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

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

#install_url_optional_parameters(options) ⇒ Object



139
140
141
142
143
# File 'lib/facebooker/session.rb', line 139

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



566
567
568
# File 'lib/facebooker/session.rb', line 566

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

#instance_variable_value(field) ⇒ Object



570
571
572
# File 'lib/facebooker/session.rb', line 570

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



367
368
369
370
# File 'lib/facebooker/session.rb', line 367

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



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

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

#login_url_optional_parameters(options) ⇒ Object



152
153
154
155
156
157
158
159
160
161
162
163
164
# File 'lib/facebooker/session.rb', line 152

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 << "&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

#marshal_dumpObject

Only serialize the bare minimum to recreate the session.



551
552
553
# File 'lib/facebooker/session.rb', line 551

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.



546
547
548
# File 'lib/facebooker/session.rb', line 546

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

#mobileObject



394
395
396
# File 'lib/facebooker/session.rb', line 394

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

#pages(options = {}) ⇒ Object

Raises:

  • (ArgumentError)


356
357
358
359
360
361
362
363
364
# File 'lib/facebooker/session.rb', line 356

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

  • read_mailbox



125
126
127
128
129
130
# File 'lib/facebooker/session.rb', line 125

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



671
672
673
674
675
676
677
678
679
# File 'lib/facebooker/session.rb', line 671

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



681
682
683
684
685
686
687
688
# File 'lib/facebooker/session.rb', line 681

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



658
659
660
661
662
663
664
665
666
667
668
669
# File 'lib/facebooker/session.rb', line 658

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



528
529
530
531
532
533
534
# File 'lib/facebooker/session.rb', line 528

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



492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
# File 'lib/facebooker/session.rb', line 492

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_comment(xid, comment_id) ⇒ Object

remove a comment from a given xid stream with comment_id



428
429
430
# File 'lib/facebooker/session.rb', line 428

def remove_comment(xid,comment_id)
  post('facebook.comments.remove', :xid=>xid, :comment_id =>comment_id)
end

#secret_for_method(method_name) ⇒ Object



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

def secret_for_method(method_name)
  @secret_key
end

#secure!(args = {}) ⇒ Object



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

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

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



210
211
212
213
214
215
# File 'lib/facebooker/session.rb', line 210

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

#secure_with_session_secret!Object



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

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

#secured?Boolean

Returns:

  • (Boolean)


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

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



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

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

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



475
476
477
478
479
480
481
482
483
484
485
486
487
# File 'lib/facebooker/session.rb', line 475

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_cacheObject

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



376
377
378
# File 'lib/facebooker/session.rb', line 376

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

#to_yaml(opts = {}) ⇒ Object

Only serialize the bare minimum to recreate the session.



556
557
558
559
560
561
562
563
564
# File 'lib/facebooker/session.rb', line 556

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

#userObject



275
276
277
# File 'lib/facebooker/session.rb', line 275

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

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



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

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



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

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