source: perl/modules/Facebook/lib/BarnOwl/Module/Facebook/Handle.pm @ fd92f78

Last change on this file since fd92f78 was fd92f78, checked in by Edward Z. Yang <ezyang@mit.edu>, 11 years ago
Informative messages upon posting. Signed-off-by: Edward Z. Yang <ezyang@mit.edu>
  • Property mode set to 100644
File size: 16.7 KB
RevLine 
[ee98987]1use warnings;
2use strict;
3
4=head1 NAME
5
6BarnOwl::Module::Facebook::Handle
7
8=head1 DESCRIPTION
9
10Contains everything needed to send and receive messages from Facebook
11
12=cut
13
14package BarnOwl::Module::Facebook::Handle;
15
16use Facebook::Graph;
[9da6022]17
[61d7594]18use List::Util qw(reduce);
19
20eval { require Lingua::EN::Keywords; };
21if ($@) {
22    *keywords = sub {
23        # stupidly pick the longest one, and only return one.
24        my $sentence = shift;
[67f6d7d]25        $sentence =~ s/[[:punct:]]+/ /g;
[61d7594]26        my @words = split(' ', lc($sentence));
27        return () unless @words;
28        return (reduce{ length($a) > length($b) ? $a : $b } @words,);
29    };
30} else {
31    *keywords = \&Lingua::EN::Keywords::keywords;
32}
[9da6022]33
[ee98987]34use JSON;
[718c23f]35use Date::Parse;
36use POSIX;
[bc56a0d]37use Ouch;
[ee98987]38
39use Scalar::Util qw(weaken);
40
41use BarnOwl;
42use BarnOwl::Message::Facebook;
43
44our $app_id = 235537266461636; # for application 'barnowl'
45
[718c23f]46# Unfortunately, Facebook does not offer a comment stream, in the same
47# way we can get a post stream using the news feed.  This makes it a bit
48# difficult to de-duplicate comments we have already seen.  We use a
49# simple heuristic to fix this: we check if the comment's time is dated
50# from before our last update, and don't re-post if it's dated before.
51# Be somewhat forgiving, since it's better to duplicate a post than to
52# drop one.  Furthermore, we must use Facebook's idea of time, since the
53# server BarnOwl is running on may be desynchronized.  So we need to
54# utilize Facebook's idea of time, not ours.  We do this by looking at
55# all of the timestamps we see while processing an update, and take the
56# latest one and increment it by one second.
57#
58# What properties do we get with this setup?
59#
60#   - We get comment updates only for the latest N posts on a news feed.
61#   Any later ones, you have to use Facebook's usual mechanisms (e.g.
62#   email notifications).
63#
64#   - Processing a poll is relatively expensive, since we have to
65#   iterate over N new posts.  It might be worthwhile polling for new
66#   comments less frequently than polling for new posts.
67
[ee98987]68sub new {
69    my $class = shift;
70    my $cfg = shift;
71
72    my $self = {
73        'cfg'  => $cfg,
74        'facebook' => undef,
[718c23f]75
[c833c3d]76        # Ideally this should be done using Facebook realtime updates,
77        # but we can't assume that the BarnOwl lives on a publically
78        # addressable server (XXX maybe we can setup an option for this.)
79        'friend_timer' => undef,
80
[718c23f]81        # Initialized with our 'time', but will be synced to Facebook
[c833c3d]82        # soon enough. (Subtractive amount is just to preseed with some
[bc56a0d]83        # values.) XXX Remove subtraction altogether.
84        'last_poll' => time - 60 * 60,
[ee98987]85        'timer' => undef,
[718c23f]86
87        # Message polling not implemented yet
88        #'last_message_poll' => time,
89        #'message_timer' => undef,
90
[ee98987]91        # yeah yeah, inelegant, I know.  You can try using
92        # $fb->authorize, but at time of writing (1.0300) they didn't support
93        # the response_type parameter.
[bc56a0d]94        # 'login_url' => 'https://www.facebook.com/dialog/oauth?client_id=235537266461636&scope=read_stream,read_mailbox,publish_stream,offline_access,read_friendlists,rsvp_event,user_events&redirect_uri=http://www.facebook.com/connect/login_success.html&response_type=token',
[ee98987]95        # minified to fit in most terminal windows.
[bc56a0d]96        # Be careful about updating these values, since BarnOwl will not
97        # notice that it is missing necessary permissions until it
98        # attempt to perform an operation which fails due to lack of
99        # permissions.
100        'login_url' => 'http://goo.gl/rcM9s',
[718c23f]101
[9da6022]102        'logged_in' => 0,
103
104        # would need another hash for topic de-dup
105        'topics' => {},
[c833c3d]106
107        # deduplicated map of names to user ids
108        'friends' => {},
[ee98987]109    };
110
111    bless($self, $class);
112
[e5b119a]113    $self->{facebook} = Facebook::Graph->new(app_id => $app_id);
114    if (defined $self->{cfg}->{token}) {
[9776805]115        $self->facebook_do_auth;
116    }
[ee98987]117
118    return $self;
119}
120
121=head2 sleep N
122
123Stop polling Facebook for N seconds.
124
125=cut
126
127sub sleep {
128    my $self  = shift;
129    my $delay = shift;
130
131    # prevent reference cycles
132    my $weak = $self;
133    weaken($weak);
134
135    # Stop any existing timers.
[c833c3d]136    if (defined $self->{friend_timer}) {
137        $self->{friend_timer}->stop;
138        $self->{friend_timer} = undef;
139    }
[ee98987]140    if (defined $self->{timer}) {
141        $self->{timer}->stop;
142        $self->{timer} = undef;
143    }
144    if (defined $self->{message_timer}) {
145        # XXX doesn't do anything right now
146        $self->{message_timer}->stop;
147        $self->{message_timer} = undef;
148    }
149
[c833c3d]150    $self->{friend_timer} = BarnOwl::Timer->new({
151        name     => "Facebook friend poll",
152        after    => $delay,
153        interval => 60 * 60 * 24,
154        cb       => sub { $weak->poll_friends if $weak }
155       });
[ee98987]156    $self->{timer} = BarnOwl::Timer->new({
157        name     => "Facebook poll",
158        after    => $delay,
159        interval => 90,
160        cb       => sub { $weak->poll_facebook if $weak }
161       });
162    # XXX implement message polling
163}
164
[bc56a0d]165sub check_result {
166    my $self = shift;
[9820d55]167    if (kiss "OAuthException") {
[bc56a0d]168        $self->{logged_in} = 0;
169        $self->facebook_do_auth;
170        return 0;
171    } elsif (hug) {
172        my $code = $@->code;
173        warn "Poll failed with $code: $@";
174        return 0;
175    }
176    return 1;
177}
178
[c833c3d]179sub poll_friends {
180    my $self = shift;
181
182    return unless BarnOwl::getvar('facebook:poll') eq 'on';
183    return unless $self->{logged_in};
184
[9820d55]185    $self->{facebook}->query->find('me/friends')->request(sub {
186        my $response = shift;
187        my $friends = eval { $response->as_hashref };
188        return unless $self->check_result;
189
190        $self->{friends} = {};
191
192        for my $friend (@{$friends->{data}}) {
193            if (defined $self->{friends}{$friend->{name}}) {
194                # XXX We should try a little harder here, rather than just
195                # tacking on a number.  Ideally, we should be able to
196                # calculate some extra piece of information that the user
197                # needs to disambiguate between the two users.  An old
198                # version of Facebook used to disambiguate with your primary
199                # network (so you might have Edward Yang (MIT) and Edward
200                # Yang (Cambridge), the idea being that users in the same
201                # network would probably have already disambiguated
202                # themselves with middle names or nicknames.  We no longer
203                # get network information, since Facebook axed that
204                # information, but the Education/Work fields may still be
205                # a reasonable approximation (but which one do you pick?!
206                # The most recent one.)  Since getting this information
207                # involves extra queries, there are also caching and
208                # efficiency concerns (though hopefully you don't have too
209                # many friends with the same name).  Furthermore, accessing
210                # this information requires a pretty hefty extra set of
211                # permissions requests, which we don't currently ask for.
212                #   It may just be better to let users specify custom
213                # aliases for Facebook users, which are added into this
214                # hash.  See also username support.
215                warn "Duplicate friend name " . $friend->{name};
216                my $name = $friend->{name};
217                my $i = 2;
218                while (defined $self->{friends}{$friend->{name} . ' ' . $i}) { $i++; }
219                $self->{friends}{$friend->{name} . ' ' . $i} = $friend->{id};
220            } else {
221                $self->{friends}{$friend->{name}} = $friend->{id};
222            }
[c833c3d]223        }
224
[9820d55]225        # XXX We should also have support for usernames, and not just real
226        # names. However, since this data is not returned by the friends
227        # query, it would require a rather expensive set of queries. We
228        # might try to preserve old data, but all-in-all it's a bit
229        # complicated.  One possible way of fixing this is to construct a
230        # custom FQL query that joins the friends table and the users table.
231    });
[c833c3d]232}
233
[ee98987]234sub poll_facebook {
235    my $self = shift;
236
237    return unless BarnOwl::getvar('facebook:poll') eq 'on';
238    return unless $self->{logged_in};
239
[718c23f]240    # XXX Oh no! This blocks the user interface.  Not good.
241    # Ideally, we should have some worker thread for polling facebook.
242    # But BarnOwl is probably not thread-safe >_<
[ee98987]243
[9da6022]244    my $old_topics = $self->{topics};
245    $self->{topics} = {};
246
[9820d55]247    $self->{facebook}
248         ->query
249         ->from("my_news")
250         # Not using this, because we want to pick up comment
251         # updates. We need to manually de-duplicate, though.
252         # ->where_since("@" . $self->{last_poll})
253         # Facebook doesn't actually give us that many results.
254         # But it can't hurt to ask!
255         ->limit_results(200)
256         ->request(sub {
257
258        my $updates = eval { shift->as_hashref };
259        return unless $self->check_result;
[a98e071]260
[9820d55]261        my $new_last_poll = $self->{last_poll};
262        for my $post (reverse @{$updates->{data}}) {
263            # No app invites, thanks! (XXX make configurable)
264            if ($post->{type} eq 'link' && $post->{application}) {
265                next;
266            }
[718c23f]267
[9820d55]268            # XXX Filtering out interest groups for now
269            # A more reasonable strategy may be to show their
270            # posts, but not the comments.
271            if (defined $post->{from}{category}) {
272                next;
273            }
[a8e1fcf]274
[9820d55]275            # There can be multiple recipients! Strange! Pick the first one.
276            my $name    = $post->{to}{data}[0]{name} || $post->{from}{name};
277            my $name_id = $post->{to}{data}[0]{id} || $post->{from}{id};
278            my $post_id  = $post->{id};
279
280            my $topic;
281            if (defined $old_topics->{$post_id}) {
282                $topic = $old_topics->{$post_id};
283                $self->{topics}->{$post_id} = $topic;
284            } else {
285                my @keywords = keywords($post->{name} || $post->{message});
286                $topic = $keywords[0] || 'personal';
287                $topic =~ s/ /-/g;
288                $self->{topics}->{$post_id} = $topic;
289            }
[718c23f]290
[9820d55]291            # Only handle post if it's new
292            my $created_time = str2time($post->{created_time});
293            if ($created_time >= $self->{last_poll}) {
294                # XXX indexing is fragile
[718c23f]295                my $msg = BarnOwl::Message->new(
296                    type      => 'Facebook',
[9820d55]297                    sender    => $post->{from}{name},
298                    sender_id => $post->{from}{id},
[718c23f]299                    name      => $name,
300                    name_id   => $name_id,
301                    direction => 'in',
[9820d55]302                    body      => $self->format_body($post),
[bc56a0d]303                    post_id   => $post_id,
304                    topic     => $topic,
[9820d55]305                    time      => asctime(localtime $created_time),
306                    # XXX The intent is to get the 'Comment' link, which also
307                    # serves as a canonical link to the post.  The {name}
308                    # field should equal 'Comment'.
309                    permalink => $post->{actions}[0]{link},
[718c23f]310                   );
311                BarnOwl::queue_message($msg);
312            }
[9820d55]313
314            # This will interleave times (they'll all be organized by parent
315            # post), but since we don't expect too many updates between
316            # polls this is pretty acceptable.
317            my $updated_time = str2time($post->{updated_time});
318            if ($updated_time >= $self->{last_poll} && defined $post->{comments}{data}) {
319                for my $comment (@{$post->{comments}{data}}) {
320                    my $comment_time = str2time($comment->{created_time});
321                    if ($comment_time < $self->{last_poll}) {
322                        next;
323                    }
324                    my $msg = BarnOwl::Message->new(
325                        type      => 'Facebook',
326                        sender    => $comment->{from}{name},
327                        sender_id => $comment->{from}{id},
328                        name      => $name,
329                        name_id   => $name_id,
330                        direction => 'in',
331                        body      => $comment->{message},
332                        post_id   => $post_id,
333                        topic     => $topic,
334                        time      => asctime(localtime $comment_time),
335                        permalink => "",
336                       );
337                    BarnOwl::queue_message($msg);
338                }
339            }
340            if ($updated_time + 1 > $new_last_poll) {
341                $new_last_poll = $updated_time + 1;
342            }
[718c23f]343        }
[9820d55]344        # old_topics gets GC'd
[718c23f]345
[9820d55]346        $self->{last_poll} = $new_last_poll;
347    });
[ee98987]348}
349
350sub format_body {
351    my $self = shift;
352
353    my $post = shift;
354
355    # XXX implement optional URL minification
356    if ($post->{type} eq 'status') {
357        return $post->{message};
358    } elsif ($post->{type} eq 'link' || $post->{type} eq 'video' || $post->{type} eq 'photo') {
359        return $post->{name}
360          . ($post->{caption} ? " (" . $post->{caption} . ")\n" : "\n")
361          . $post->{link}
362          . ($post->{description} ? "\n\n" . $post->{description} : "")
363          . ($post->{message} ? "\n\n" . $post->{message} : "");
364    } else {
365        return "(unknown post type " . $post->{type} . ")";
366    }
367}
368
[bc56a0d]369# Invariant: we don't become logged out between entering text field
370# and actually processing the request.  XXX I don't think this actually
371# holds, but such a case would rarely happen.
372
[ee98987]373sub facebook {
374    my $self = shift;
375
[c833c3d]376    my $user = shift;
[ee98987]377    my $msg = shift;
378
[83e90de]379    my $cont = sub {
380        eval { shift->as_hashref };
381        return unless $self->check_result;
[fd92f78]382        BarnOwl::message("Submitted!");
383        $self->sleep(1); # give a bit of time to quiesce
[83e90de]384    };
[9820d55]385
[c833c3d]386    if (defined $user) {
387        $user = $self->{friends}{$user} || $user;
[9820d55]388        $self->{facebook}->add_post($user)->set_message($msg)->publish($cont);
[c833c3d]389    } else {
[9820d55]390        $self->{facebook}->add_post->set_message($msg)->publish($cont);
[c833c3d]391    }
[fd92f78]392    BarnOwl::message("Submitting Facebook post...");
[ee98987]393}
394
395sub facebook_comment {
396    my $self = shift;
397
[2226f91]398    my $post_id = shift;
[ee98987]399    my $msg = shift;
400
[83e90de]401    $self->{facebook}->add_comment($post_id)->set_message($msg)->publish(sub {
402        eval { shift->as_hashref };
403        return unless $self->check_result;
[fd92f78]404        BarnOwl::message("Submitted!");
405        $self->sleep(1); # give a bit of time to quiesce
[83e90de]406    });
[fd92f78]407    BarnOwl::message("Submitting Facebook comment...");
[ee98987]408}
409
410sub facebook_auth {
411    my $self = shift;
412
413    my $url = shift;
[bc56a0d]414
[9776805]415    if (!defined $url) {
416        $self->facebook_do_auth;
417        return;
418    }
419
[ee98987]420    # http://www.facebook.com/connect/login_success.html#access_token=TOKEN&expires_in=0
421    $url =~ /access_token=([^&]+)/; # XXX Ew regex
422
[bc56a0d]423    if (!defined $1) {
424        BarnOwl::message("Invalid URL.");
425        return;
426    }
427
[ee98987]428    $self->{cfg}->{token} = $1;
[9820d55]429    $self->facebook_do_auth(sub {
[ee98987]430        my $raw_cfg = to_json($self->{cfg});
431        BarnOwl::admin_message('Facebook', "Add this as the contents of your ~/.owl/facebook file:\n$raw_cfg");
[9820d55]432    });
433    return;
[ee98987]434}
435
436sub facebook_do_auth {
437    my $self = shift;
[9820d55]438    my $success = shift || sub {};
[e5b119a]439    if (!defined $self->{cfg}->{token}) {
[ee98987]440        BarnOwl::admin_message('Facebook', "Login to Facebook at ".$self->{login_url}
[bc56a0d]441            . "\nand run command ':facebook-auth URL' with the URL you are redirected to."
[cb5d448]442            . "\n\nWhat does BarnOwl use these permissions for?  As a desktop"
[bc56a0d]443            . "\nmessaging application, we need persistent read/write access to your"
444            . "\nnews feed and your inbox.  Other permissions are for pending"
445            . "\nfeatures: we intend on adding support for event streaming, RSVP,"
446            . "\nand BarnOwl filtering on friend lists."
447        );
[ee98987]448        return 0;
449    }
450    $self->{facebook}->access_token($self->{cfg}->{token});
451    # Do a quick check to see if things are working
[83e90de]452    #$self->{facebook}->query()->find('me')->select_fields('name')->request(sub {
[fd92f78]453    # Added 'localtime time' to avoid duplicate checks.
[83e90de]454    $self->{facebook}->add_post->set_message("Logged in to BarnOwl at " . localtime time)->set_privacy('CUSTOM', {friends => 'SELF'})->publish(sub {
[9820d55]455        my $result = eval { shift->as_hashref };
456        if ($@) {
457            BarnOwl::admin_message('Facebook', "Failed to authenticate with '$@'!"
458                . "\nLogin to Facebook at ".$self->{login_url}
459                . "\nand run command ':facebook-auth URL' with the URL you are redirected to.");
460        } else {
[83e90de]461            $self->{facebook}->delete($result->{id}, sub {
462                BarnOwl::admin_message('Facebook', "Successfully logged in to Facebook.");
463                $self->{logged_in} = 1;
464                $self->sleep(0); # start polling
465                $success->();
466            });
[9820d55]467        }
468    });
[ee98987]469}
470
4711;
Note: See TracBrowser for help on using the repository browser.