Changeset 1577 for trunk

Show
Ignore:
Timestamp:
08/28/09 20:03:43 (3 months ago)
Author:
btrott
Message:

Updated to support Fire Eagle's 1.0a oauth requirement.

Upgraded Net::OAuth and Net::FireEagle?; added Net::OAuth::Simple; removed
URI::Escape because this version is no longer required.

Updated the oauth setup flow for the plugin to pass in an "oob" callback
and provide a box to enter the verification code.

Location:
trunk/FireEagle/plugins/FireEagle
Files:
14 added
1 removed
10 modified

Legend:

Unmodified
Added
Removed

  • trunk/FireEagle/plugins/FireEagle/fireeagle.pl

    r603 r1577  
    99use URI::Escape; 
    1010 
    11 our $VERSION = '1.03'; 
     11our $VERSION = '1.04'; 
    1212 
    1313our $ConsumerKey = 'q6QnDA0V96yU'; 
    … …  
    118118        return unless $id == $app->user->id; 
    119119    } 
    120     if ( my $userpic_node = $tmpl->getElementById( 'userpic_asset_id' ) ) { 
     120    if ( my $userpic_node = $tmpl->getElementById( 'url' ) ) { 
    121121        my $node = $tmpl->createElement( 'app:setting', { 
    122122            id              => 'fireeagle-location', 
    … …  
    166166    unless ( $app->param( 'done' ) ) { 
    167167        my $fe = _fireeagle_client(); 
     168        $fe->callback( 'oob' ); 
    168169        %arg = ( 
    169170            id                      => $app->user->id, 
    170171            auth_uri                => $fe->get_authorization_url, 
    171             request_token           => $fe->{request_token}, 
    172             request_token_secret    => $fe->{request_token_secret}, 
     172            request_token           => $fe->request_token, 
     173            request_token_secret    => $fe->request_token_secret, 
    173174        ); 
    174175    } else { 
    … …  
    186187    my( $app ) = @_; 
    187188    my $fe = _fireeagle_client(); 
    188     $fe->{request_token} = $app->param( 'request_token' ); 
    189     $fe->{request_token_secret} = $app->param( 'request_token_secret' ); 
    190     $fe->request_access_token; ## trap errors 
     189    $fe->request_access_token( 
     190        token           => $app->param( 'request_token' ), 
     191        token_secret    => $app->param( 'request_token_secret' ), 
     192        verifier        => $app->param( 'verifier' ), 
     193    ); 
    191194    my $user = $app->user; 
    192195    $user->meta( 'fireeagle_access_token', $fe->access_token ); 

  • trunk/FireEagle/plugins/FireEagle/lib/Net/FireEagle.pm

    r958 r1577  
    33# Client library for FireEagle 
    44use strict; 
    5 use LWP; 
    6 use CGI; 
    7 use Carp; 
    8 require Net::OAuth::Request; 
    9 require Net::OAuth::RequestTokenRequest; 
    10 require Net::OAuth::AccessTokenRequest; 
    11 require Net::OAuth::ProtectedResourceRequest; 
    12  
    13 BEGIN { 
    14     eval {  require Math::Random::MT }; 
    15     unless ($@) { 
    16         Math::Random::MT->import(qw(srand rand)); 
    17     } 
    18 } 
    19  
    20 our $VERSION = '1.2'; 
    21 our $DEBUG   = 0; 
     5use base qw(Net::OAuth::Simple); 
     6 
     7our $VERSION = '1.6'; 
    228 
    239# FireEagle Endpoint URLs 
    … …  
    2814our $UPDATE_API_URL    = 'https://fireeagle.yahooapis.com/api/0.1/update'; 
    2915our $LOOKUP_API_URL    = 'https://fireeagle.yahooapis.com/api/0.1/lookup'; 
    30 our $SIGNATURE_METHOD  = 'HMAC-SHA1'; 
    31 our $UNAUTHORIZED      = "Unauthorized."; 
    32  
    33 our @required_constructor_params = qw(consumer_key consumer_secret); 
    34 our @access_token_params         = qw(access_token access_token_secret); 
     16our $WITHIN_API_URL    = 'https://fireeagle.yahooapis.com/api/0.1/within'; 
     17our $RECENT_API_URL    = 'https://fireeagle.yahooapis.com/api/0.1/recent'; 
    3518 
    3619 
    … …  
    139122=back 
    140123 
     124Alternatively when you create a new web-based application, a general-purpose  
     125access token is issued to you along with your application key and secret. You 
     126can get them at http://fireeagle.yahoo.net/developer/manage. 
     127 
     128They are tied to your application and allow your application to make  
     129general-purpose API method calls (often batch-style) to Fire Eagle. 
     130 
     131You can read about them at 
     132 
     133    http://fireagle.yahoo.net/developer/documentation/using_oauth#feaccesstokens 
     134 
     135 
     136 
     137You can pass them in using the param 
     138 
     139=over 4 
     140 
     141=item general_token 
     142 
     143=item general_token_secret 
     144 
     145=back 
     146 
    141147=cut 
    142148 
    … …  
    144150    my $proto  = shift; 
    145151    my $class  = ref $proto || $proto; 
    146     my %params = @_; 
    147     my $client = bless \%params, $class; 
    148  
    149     # Verify arguments 
    150     $client->_check; 
    151  
    152     # Set up LibWWWPerl for HTTP requests 
    153     $client->{browser} = LWP::UserAgent->new; 
    154  
    155     # Client Object 
    156     return $client; 
    157 } 
    158  
    159  
    160  
    161 # Validate required constructor params 
    162 sub _check { 
    163     my $self = shift; 
    164     foreach my $param ( @required_constructor_params ) { 
    165         if ( not defined $self->{$param} ) { 
    166             die "Missing required parameter '$param'"; 
    167         } 
    168     } 
    169 } 
    170  
    171 =head2 authorized 
    172  
    173 Whether the client has the necessary credentials to be authorized. 
    174  
    175 Note that the credentials may be wrong and so the request may still fail. 
    176  
    177 =cut 
    178  
    179 sub authorized { 
    180     my $self = shift; 
    181     foreach my $param ( @access_token_params ) { 
    182         if ( not defined $self->{$param} ) { return 0; } 
    183     } 
    184     return 1; 
    185 } 
    186  
    187 =head2 consumer_key [consumer key] 
    188  
    189 Returns the current consumer key.  
    190  
    191 Can optionally set the consumer key. 
    192  
    193 =cut 
    194  
    195 sub consumer_key { 
    196     my $self = shift; 
    197     $self->_access('consumer_key', @_); 
    198 } 
    199  
    200 =head2 consumer_secret [consumer secret] 
    201  
    202 Returns the current consumer secret. 
    203  
    204 Can optionally set the consumer secret. 
    205  
    206 =cut 
    207  
    208 sub consumer_secret { 
    209     my $self = shift; 
    210     $self->_access('consumer_secret', @_); 
    211 } 
    212  
    213  
    214 =head2 access_token [access_token] 
    215  
    216 Returns the current access token. 
    217  
    218 Can optionally set a new token. 
    219  
    220 =cut 
    221  
    222 sub access_token { 
    223     my $self = shift; 
    224     $self->_access('access_token', @_); 
    225 } 
    226  
    227  
    228 =head2 access_token_secret [access_token_secret] 
    229  
    230 Returns the current access token secret. 
    231  
    232 Can optionally set a new secret. 
    233  
    234 =cut 
    235  
    236 sub access_token_secret { 
    237     my $self = shift; 
    238     return $self->_access('access_token_secret', @_); 
    239 } 
    240  
    241 =head2 request_token [request_token] 
    242  
    243 Returns the current request token. 
    244  
    245 Can optionally set a new token. 
    246  
    247 =cut 
    248  
    249 sub request_token { 
    250     my $self = shift; 
    251     $self->_access( 'request_token', @_); 
    252 } 
    253  
    254  
    255 =head2 request_token_secret [request_token_secret] 
    256  
    257 Returns the current request token secret. 
    258  
    259 Can optionally set a new secret. 
    260  
    261 =cut 
    262  
    263 sub request_token_secret { 
    264     my $self = shift; 
    265     return $self->_access( 'request_token_secret', @_); 
    266 } 
    267  
    268  
    269  
    270  
    271  
    272 sub _access { 
    273     my $self = shift; 
    274     my $key  = shift; 
    275     $self->{$key} = shift if @_; 
    276     return $self->{$key}; 
    277 } 
    278  
    279 # generate a random number  
    280 sub _nonce { 
    281     return int( rand( 2**32 ) ); 
    282 } 
    283  
    284 =head2 request_access_token 
    285  
    286 Request the access token and access token secret for this user. 
    287  
    288 The user must have authorized this app at the url given by 
    289 C<get_authorization_url> first. 
    290  
    291 Returns the access token and access token secret but also sets  
    292 them internally so that after calling this method you can  
    293 immediately call C<location> or C<update_location>. 
    294  
    295 =cut 
    296  
    297 sub request_access_token { 
    298     my $self = shift; 
    299     print "REQUESTING ACCESS TOKEN\n" if $DEBUG; 
    300     my $access_token_response = $self->_make_request( 
    301         'Net::OAuth::AccessTokenRequest', 
    302         $ACCESS_TOKEN_URL, 'GET', 
    303         token            => $self->{request_token}, 
    304         token_secret     => $self->{request_token_secret}, 
    305     ); 
    306  
    307     # Cast response into CGI query for EZ parameter decoding 
    308     my $access_token_response_query = 
    309       new CGI( $access_token_response->content ); 
    310  
    311     # Split out token and secret parameters from the access token response 
    312     $self->{access_token} = $access_token_response_query->param('oauth_token'); 
    313     $self->{access_token_secret} = 
    314       $access_token_response_query->param('oauth_token_secret'); 
    315  
    316     die "ERROR: FireEagle did not reply with an access token" 
    317       unless ( $self->{access_token} && $self->{access_token_secret} ); 
    318          
    319     return ( $self->{access_token}, $self->{access_token_secret} ); 
    320 } 
    321  
    322  
    323 sub _request_request_token { 
    324     my $self                   = shift; 
    325     my $request_token_response = $self->_make_request( 
    326         'Net::OAuth::RequestTokenRequest', 
    327         $REQUEST_TOKEN_URL, 'GET'); 
    328  
    329     die "GET for $REQUEST_TOKEN_URL failed: ".$request_token_response->status_line 
    330       unless ( $request_token_response->is_success ); 
    331  
    332     # Cast response into CGI query for EZ parameter decoding 
    333     my $request_token_response_query = 
    334       new CGI( $request_token_response->content ); 
    335  
    336     # Split out token and secret parameters from the request token response 
    337     $self->{request_token} = 
    338       $request_token_response_query->param('oauth_token'); 
    339     $self->{request_token_secret} = 
    340       $request_token_response_query->param('oauth_token_secret'); 
    341  
    342 } 
    343  
    344 =head2 get_authorization_url 
    345  
    346 Get the URL to authorize a user. 
    347  
    348 =cut 
    349  
    350 sub get_authorization_url { 
    351     my $self = shift; 
    352  
    353     if (!defined $self->{request_token}) { 
    354         $self->_request_request_token; 
    355     } 
    356     return $AUTHORIZATION_URL . '?oauth_token=' . $self->{request_token}; 
    357 } 
    358  
     152    my %tokens = @_; 
     153 
     154    return $class->SUPER::new( tokens => \%tokens, 
     155                               urls   => { 
     156                                authorization_url => $AUTHORIZATION_URL, 
     157                                request_token_url => $REQUEST_TOKEN_URL, 
     158                                access_token_url  => $ACCESS_TOKEN_URL, 
     159                            });         
     160 
     161} 
    359162 
    360163=head2 location [opt[s] 
    … …  
    379182 
    380183    my $url = $QUERY_API_URL;  
    381         
    382     $url .= '.'.$opts{format} if defined $opts{format}; 
     184    $url   .= '.'.$opts{format} if defined $opts{format}; 
    383185 
    384186    return $self->_make_restricted_request($url, 'GET'); 
    … …  
    404206    my %opts     = @_; 
    405207    
    406     my $extras = $self->_munge_location($location); 
     208    my %extras   = $self->_munge('address', $location); 
    407209     
    408     my $url  = $UPDATE_API_URL;  
    409         
    410     $url  .= '.'.$opts{format} if defined $opts{format}; 
     210    my $url      = $UPDATE_API_URL;  
     211    $url        .= '.'.$opts{format} if defined $opts{format}; 
    411212     
    412     return $self->_make_restricted_request($url, 'POST', $extras); 
     213    return $self->_make_restricted_request($url, 'POST', %extras); 
    413214} 
    414215 
    … …  
    434235    my %opts     = @_; 
    435236   
    436     my $extras = $self->_munge_location($location); 
    437  
    438     my $url = $LOOKUP_API_URL;  
     237    my %extras   = $self->_munge('address', $location); 
     238    my $url      = $LOOKUP_API_URL; 
     239    $url        .= '.'.$opts{format} if defined $opts{format}; 
    439240     
    440     $url .= '.'.$opts{format} if defined $opts{format}; 
    441      
    442     return $self->_make_restricted_request($url, 'GET', $extras); 
    443 } 
    444  
    445 sub _munge_location { 
    446     my $self  = shift; 
    447     my $loc   = shift; 
    448     my $ref   = ref($loc); 
    449     return { address => $loc } if !defined $ref or "" eq $ref; 
    450     return $loc                if 'HASH' eq $ref; 
    451     die "Can't understand location parameter in the form of a $ref ref";   
     241    return $self->_make_restricted_request($url, 'GET', %extras); 
     242} 
     243 
     244=head2 within <query> <opt[s]> 
     245 
     246Takes a Place ID or a WoE ID and returns a list of users using your  
     247application who are within the bounding box of that location. 
     248 
     249Return the result of the update in either xml or json 
     250depending on C<opts>. 
     251 
     252The query can either be a plain string or a hash reference containing 
     253location parameters as described in 
     254 
     255    http://fireeagle.yahoo.net/developer/documentation/location#locparams 
     256 
     257=cut 
     258 
     259sub within { 
     260    my $self     = shift; 
     261    my $location = shift; 
     262    my %opts     = @_; 
     263 
     264    my %extras   = $self->_munge('address', $location); 
     265    my $url      = $WITHIN_API_URL; 
     266    $url        .= '.'.$opts{format} if defined $opts{format}; 
     267 
     268    return $self->_make_restricted_request_general($url, 'GET', %extras); 
     269} 
     270 
     271 
     272=head2 recent <query> [opt[s]] 
     273 
     274Query for users of an Application who have updated their locations recently.  
     275 
     276Return the result of the update in either xml or json 
     277depending on C<opts>. 
     278 
     279Query is either a number representing a unix time stamp, to 
     280specify the earliest update to return, or a hash reference containing  
     281parameters as described in 
     282 
     283    http://fireagle.yahoo.net/developer/documentation/querying#recent 
     284 
     285=cut 
     286 
     287sub recent { 
     288     my $self   = shift; 
     289     my $time   = shift; 
     290     my %opts   = @_; 
     291 
     292     my %extras = $self->_munge('time', $time); 
     293     my $url    = $RECENT_API_URL; 
     294     $url      .= '.'.$opts{format} if defined $opts{format}; 
     295 
     296     return $self->_make_restricted_request_general($url, 'GET', %extras); 
     297} 
     298 
     299sub _make_restricted_request_general { 
     300     my $self     = shift; 
     301     my $response = $self->make_general_request(@_); 
     302     return $response->content; 
    452303} 
    453304 
    454305sub _make_restricted_request { 
    455306    my $self     = shift; 
    456  
    457     croak $UNAUTHORIZED unless $self->authorized; 
    458  
    459     my $url      = shift; 
    460     my $method   = shift; 
    461     my $extra    = shift || {}; 
    462      my $response = $self->_make_request( 
    463         'Net::OAuth::ProtectedResourceRequest', 
    464         $url, $method,  
    465         token            => $self->{access_token}, 
    466         token_secret     => $self->{access_token_secret}, 
    467         extra_params     => $extra, 
    468     ); 
     307    my $response = $self->make_restricted_request(@_); 
    469308    return $response->content; 
    470309} 
    471310 
    472 sub _make_request { 
    473     my $self    = shift; 
    474  
    475     my $class   = shift; 
    476     my $url     = shift; 
    477     my $method  = lc(shift); 
    478     my %extra   = @_; 
    479  
    480     my $request = $class->new( 
    481         consumer_key     => $self->{consumer_key}, 
    482         consumer_secret  => $self->{consumer_secret}, 
    483         request_url      => $url, 
    484         request_method   => uc($method), 
    485         signature_method => $SIGNATURE_METHOD, 
    486         timestamp        => time, 
    487         nonce            => $self->_nonce, 
    488         %extra, 
    489     ); 
    490     $request->sign; 
    491     die "COULDN'T VERIFY! Check OAuth parameters.\n" 
    492       unless $request->verify; 
    493  
    494     my $request_url = $url . '?' . $request->to_post_body; 
    495     my $response    = $self->{browser}->$method($request_url); 
    496     die "$method on $request_url failed: ".$response->status_line 
    497       unless ( $response->is_success ); 
    498  
    499     return $response; 
    500 } 
    501  
    502  
    503 =head1 RANDOMNESS 
    504  
    505 If C<Math::Random::MT> is installed then any nonces 
    506 generated will use a Mersenne Twiser instead of Perl's 
    507 built in randomness function. 
     311sub _munge { 
     312    my $self  = shift; 
     313    my $key   = shift; 
     314    my $item  = shift || return (); 
     315    my $ref   = ref($item); 
     316    return ( $key => $item ) if !defined $ref or "" eq $ref; 
     317    return %$item            if 'HASH' eq $ref; 
     318    die "Can't understand $key parameter in the form of a $ref ref";   
     319} 
    508320 
    509321=head1 BUGS 
    … …  
    535347=head1 SEE ALSO 
    536348 
    537 L<Net::OAuth> 
     349L<Net::OAuth::Simple> 
    538350 
    539351=cut 

  • trunk/FireEagle/plugins/FireEagle/lib/Net/OAuth/AccessTokenRequest.pm

    r533 r1577  
    44use base 'Net::OAuth::Request'; 
    55 
    6 __PACKAGE__->add_required_request_params(qw/token/); 
     6__PACKAGE__->add_required_message_params(qw/token/); 
    77__PACKAGE__->add_required_api_params(qw/token_secret/); 
    88sub allow_extra_params {0} 
     9sub sign_message {1} 
    910 
    1011=head1 NAME 
    1112 
    12 Net::OAuth::RequestTokenRequest - An OAuth protocol request for an Access Token 
     13Net::OAuth::AccessTokenRequest - An OAuth protocol request for an Access Token 
    1314 
    1415=head1 SEE ALSO 
    1516 
    16 L<Net::OAuth::Request>, L<http://oauth.net> 
     17L<Net::OAuth>, L<http://oauth.net> 
    1718 
    1819=head1 AUTHOR 

  • trunk/FireEagle/plugins/FireEagle/lib/Net/OAuth/ProtectedResourceRequest.pm

    r533 r1577  
    22use warnings; 
    33use strict; 
    4 use base 'Net::OAuth::AccessTokenRequest'; 
     4use base 'Net::OAuth::Request'; 
    55 
     6__PACKAGE__->add_required_message_params(qw/token/); 
     7__PACKAGE__->add_required_api_params(qw/token_secret/); 
    68sub allow_extra_params {1} 
     9sub sign_message {1} 
     10 
    711 
    812=head1 NAME 
    913 
    10 Net::OAuth::RequestTokenRequest - An OAuth protocol request for a Protected Resource 
     14Net::OAuth::ProtectedResourceRequest - An OAuth protocol request for a Protected Resource 
    1115 
    1216=head1 SEE ALSO 
    1317 
    14 L<Net::OAuth::Request>, L<http://oauth.net> 
     18L<Net::OAuth>, L<http://oauth.net> 
    1519 
    1620=head1 AUTHOR 

  • trunk/FireEagle/plugins/FireEagle/lib/Net/OAuth/Request.pm

    r533 r1577  
    22use warnings; 
    33use strict; 
    4 use base qw/Class::Data::Inheritable Class::Accessor/; 
    5 use URI::Escape; 
    6 use UNIVERSAL::require; 
     4use base qw/Net::OAuth::Message/; 
     5use URI; 
     6use URI::QueryParam; 
    77 
    8 our $VERSION = '0.05'; 
     8our $VERSION = '0.19'; 
    99 
    10 __PACKAGE__->mk_classdata(required_request_params => [qw/ 
     10__PACKAGE__->mk_classdata(required_message_params => [qw/ 
    1111    consumer_key 
    1212    signature_method 
    … …  
    1515    /]); 
    1616 
    17 __PACKAGE__->mk_classdata(optional_request_params => [qw/ 
     17__PACKAGE__->mk_classdata(optional_message_params => [qw/ 
    1818    version 
     19    signature 
    1920    /]); 
    2021 
    … …  
    2526    /]); 
    2627 
     28__PACKAGE__->mk_classdata(optional_api_params => [qw/ 
     29    signature_key 
     30    token_secret 
     31    extra_params 
     32    protocol_version 
     33    /]); 
     34 
    2735__PACKAGE__->mk_classdata(signature_elements => [qw/ 
    2836    request_method 
    29     request_url 
    30     normalized_request_parameters 
     37    normalized_request_url 
     38    normalized_message_parameters 
    3139    /]); 
    32      
     40 
     41__PACKAGE__->mk_classdata(all_message_params => [ 
     42    @{__PACKAGE__->required_message_params}, 
     43    @{__PACKAGE__->optional_message_params}, 
     44        ]); 
     45 
     46__PACKAGE__->mk_classdata(all_api_params => [ 
     47    @{__PACKAGE__->required_api_params}, 
     48    @{__PACKAGE__->optional_api_params},         
     49        ]); 
     50 
     51__PACKAGE__->mk_classdata(all_params => [ 
     52    @{__PACKAGE__->all_api_params}, 
     53    @{__PACKAGE__->all_message_params},  
     54        ]); 
     55 
    3356__PACKAGE__->mk_accessors( 
    34     @{__PACKAGE__->required_request_params},  
    35     @{__PACKAGE__->optional_request_params}, 
    36     @{__PACKAGE__->required_api_params}, 
    37     qw/extra_params signature signature_key token_secret/ 
     57    @{__PACKAGE__->all_params}, 
    3858    ); 
    39  
    40 sub add_required_request_params { 
    41     my $class = shift; 
    42     $class->required_request_params([@{$class->required_request_params}, @_]); 
    43     $class->mk_accessors(@_); 
    44 } 
    45  
    46 sub add_optional_request_params { 
    47     my $class = shift; 
    48     $class->optional_request_params([@{$class->optional_request_params}, @_]); 
    49     $class->mk_accessors(@_); 
    50 } 
    51  
    52 sub add_required_api_params { 
    53     my $class = shift; 
    54     $class->required_api_params([@{$class->required_api_params}, @_]); 
    55     $class->mk_accessors(@_); 
    56 } 
    57  
    58 sub add_to_signature { 
    59     my $class = shift; 
    60     $class->signature_elements([@{$class->signature_elements}, @_]); 
    61 } 
    62  
    63 sub new { 
    64     my $proto = shift; 
    65     my $class = ref $proto || $proto; 
    66     my %params = @_; 
    67     $params{version} = '1.0' unless defined $params{version}; 
    68     my $req = bless \%params, $class; 
    69     $req->check; 
    70     return $req; 
    71 } 
    72  
    73 sub check { 
    74     my $self = shift; 
    75     foreach my $k (@{$self->required_request_params}, @{$self->required_api_params}) { 
    76         if (not defined $self->{$k}) { 
    77             die "Missing required parameter '$k'"; 
    78         } 
    79     } 
    80     if ($self->{extra_params} and $self->allow_extra_params) { 
    81         foreach my $k (keys %{$self->{extra_params}}) { 
    82             if ($k =~ /^oauth_/) { 
    83                 die "Parameter '$k' not allowed in arbitrary params" 
    84             } 
    85         } 
    86     } 
    87 } 
    88  
    89 sub encode { 
    90     my $str = shift; 
    91     $str = "" unless defined $str; 
    92     return URI::Escape::uri_escape_utf8($str,'^\w.~-'); 
    93 } 
    94  
    95 sub decode { 
    96     my $str = shift; 
    97     return uri_unescape($str); 
    98 } 
    99  
    100 sub allow_extra_params {1} 
    101  
    102 sub gather_request_parameters { 
    103     my $self = shift; 
    104     my %opts = @_; 
    105     $opts{quote} = "" unless defined $opts{quote}; 
    106     $opts{params} ||= []; 
    107     my %params; 
    108     foreach my $k (@{$self->required_request_params}, @{$self->optional_request_params}, @{$opts{add}}) { 
    109         $params{"oauth_$k"} = $self->$k;  
    110     } 
    111     if ($self->{extra_params} and !$opts{no_extra} and $self->allow_extra_params) { 
    112         foreach my $k (keys %{$self->{extra_params}}) { 
    113             $params{$k} = $self->{extra_params}{$k}; 
    114         } 
    115     } 
    116     if ($opts{hash}) { 
    117         return \%params; 
    118     } 
    119     my @pairs; 
    120     while (my ($k,$v) = each %params) { 
    121         push @pairs, join('=', encode($k), $opts{quote} . encode($v) . $opts{quote}); 
    122     } 
    123     return sort(@pairs); # sort not required here but makes module more testable 
    124 } 
    125  
    126 sub normalized_request_parameters { 
    127     my $self = shift; 
    128     return join('&',  $self->gather_request_parameters); 
    129 } 
    130  
    131 sub signature_base_string { 
    132     my $self = shift; 
    133     return join('&', map(encode($self->$_), @{$self->signature_elements})); 
    134 } 
    13559 
    13660sub signature_key { 
    13761    my $self = shift; 
    13862    # For some sig methods (I.e. RSA), users will pass in their own key 
    139     my $key = $self->get('signature_key');  
     63    my $key = $self->get('signature_key'); 
    14064    unless (defined $key) { 
    141         $key = encode($self->consumer_secret) . '&'; 
    142         $key .= encode($self->token_secret) if $self->can('token_secret'); 
     65        $key = Net::OAuth::Message::encode($self->consumer_secret) . '&'; 
     66        $key .= Net::OAuth::Message::encode($self->token_secret) if $self->can('token_secret'); 
    14367    } 
    14468    return $key; 
    14569} 
    14670 
    147 sub sign { 
     71sub normalized_request_url { 
    14872    my $self = shift; 
    149     my $class = $self->_signature_method_class; 
    150     $self->signature($class->sign($self, @_)); 
     73    my $url = $self->request_url; 
     74    Net::OAuth::Message::_ensure_uri_object($url); 
     75    $url->query(undef); 
     76    return $url; 
    15177} 
    15278 
    153 sub verify { 
    154     my $self = shift; 
    155     my $class = $self->_signature_method_class; 
    156     return $class->verify($self, @_); 
    157 } 
    158  
    159 sub _signature_method_class { 
    160     my $self = shift; 
    161     (my $signature_method = $self->signature_method) =~ s/\W+/_/g; 
    162     my $klass = 'Net::OAuth::SignatureMethod::' . $signature_method; 
    163     $klass->require or die "Unable to load $signature_method plugin"; 
    164     return $klass; 
    165 } 
    166  
    167 sub to_authorization_header { 
    168     my $self = shift; 
    169     my $realm = shift; 
    170     my $sep = shift || ","; 
    171     return join($sep, "OAuth realm=\"$realm\"",  
    172         $self->gather_request_parameters(quote => '"', add => [qw/signature/], no_extra => 1)); 
    173 } 
    174  
    175 sub from_authorization_header { 
    176     my $proto = shift; 
    177     my $class = ref $proto || $proto; 
    178     my $header = shift; 
    179     my %extra_params = @_; 
    180     my @header = split /[\s]*,[\s]*/, $header; 
    181     shift @header; 
    182     my %params; 
    183     foreach my $pair (@header) { 
    184         my ($k,$v) = split /=/, $pair; 
    185         if (defined $k and defined $v) { 
    186             $v =~ s/(^"|"$)//g; 
    187             ($k,$v) = map decode($_), $k, $v; 
    188             $k =~ s/^oauth_//; 
    189             $params{$k} = $v; 
    190         } 
    191     } 
    192     return $class->new(%params, %extra_params); 
    193 } 
    194  
    195 sub to_post_body { 
    196     my $self = shift; 
    197     return join('&', $self->gather_request_parameters(add => [qw/signature/])); 
    198 } 
    199  
    200 sub to_hash { 
    201     my $self = shift; 
    202     return $self->gather_request_parameters(hash => 1, add => [qw/signature/]); 
    203 } 
    20479 
    20580=head1 NAME 
    … …  
    20984=head1 SEE ALSO 
    21085 
    211 L<http://oauth.net> 
     86L<Net::OAuth>, L<http://oauth.net> 
    21287 
    21388=head1 AUTHOR 

  • trunk/FireEagle/plugins/FireEagle/lib/Net/OAuth/RequestTokenRequest.pm

    r533 r1577  
    33use strict; 
    44use base 'Net::OAuth::Request'; 
     5 
     6sub sign_message {1} 
    57 
    68=head1 NAME 
    … …  
    1012=head1 SEE ALSO 
    1113 
    12 L<Net::OAuth::Request>, L<http://oauth.net> 
     14L<Net::OAuth>, L<http://oauth.net> 
    1315 
    1416=head1 AUTHOR 

  • trunk/FireEagle/plugins/FireEagle/lib/Net/OAuth/SignatureMethod/HMAC_SHA1.pm

    r533 r1577  
    2525=head1 SEE ALSO 
    2626 
    27 L<Net::OAuth::Request>, L<http://oauth.net> 
     27L<Net::OAuth>, L<http://oauth.net> 
    2828 
    2929=head1 AUTHOR 

  • trunk/FireEagle/plugins/FireEagle/lib/Net/OAuth/SignatureMethod/PLAINTEXT.pm

    r533 r1577  
    2121=head1 SEE ALSO 
    2222 
    23 L<Net::OAuth::Request>, L<http://oauth.net> 
     23L<Net::OAuth>, L<http://oauth.net> 
    2424 
    2525=head1 AUTHOR 

  • trunk/FireEagle/plugins/FireEagle/lib/Net/OAuth/SignatureMethod/RSA_SHA1.pm

    r533 r1577  
    77    my $self = shift; 
    88    my $request = shift; 
     9        my $key = shift || $request->signature_key; 
    910    die '$request->signature_key must be an RSA key object (e.g. Crypt::OpenSSL::RSA) that can sign($text)' 
    10         unless UNIVERSAL::can($request->signature_key, 'sign'); 
    11     return encode_base64($request->signature_key->sign($request->signature_base_string), ""); 
     11        unless UNIVERSAL::can($key, 'sign'); 
     12    return encode_base64($key->sign($request->signature_base_string), ""); 
    1213} 
    1314 
    … …  
    1718    my $key = shift || $request->signature_key; 
    1819    die 'You must pass an RSA key object (e.g. Crypt::OpenSSL::RSA) that can verify($text,$sig)' 
    19         unless UNIVERSAL::can($request->signature_key, 'verify'); 
     20        unless UNIVERSAL::can($key, 'verify'); 
    2021    return $key->verify($request->signature_base_string, decode_base64($request->signature)); 
    2122} 
    … …  
    2728=head1 SEE ALSO 
    2829 
    29 L<Net::OAuth::Request>, L<http://oauth.net> 
     30L<Net::OAuth>, L<http://oauth.net> 
    3031 
    3132=head1 AUTHOR 

  • trunk/FireEagle/plugins/FireEagle/tmpl/dialog_setup_fireeagle.tmpl

    r537 r1577  
    2222    DOM.addEventListener( DOM.getElement( 'ready-button' ), 'click', function( ev ) { 
    2323        Event.stop( ev ); 
    24         window.location = '<mt:var name="script_url">?__mode=link_fireeagle_account&request_token=<mt:var name="request_token">&request_token_secret=<mt:var name="request_token_secret">'; 
     24        window.location = '<mt:var name="script_url">?__mode=link_fireeagle_account&request_token=<mt:var name="request_token">&request_token_secret=<mt:var name="request_token_secret">&verifier=' + DOM.getElement( 'verifier-input' ).value; 
    2525    } ); 
    2626} ); 
    … …  
    4848 
    4949<div id="step-two" class="hidden"> 
    50     <p style="margin-top: 15px;">When you've authorized Movable Type to access your Fire Eagle account, click the big "Ready!" button below.</p> 
     50    <p style="margin-top: 15px;">When you've authorized Movable Type to access your Fire Eagle account, Fire Eagle will give you a verification code to enter to link your accounts. Paste or type the verification code in below, then click the "Link my accounts!" button.</p> 
    5151 
    52     <button id="ready-button"><__trans phrase="READY!"></button> 
     52    <__trans phrase="Verification code:"> <input id="verifier-input" name="verifier" size="10" /> 
     53    <button id="ready-button"><__trans phrase="Link my accounts!"></button> 
    5354</div> 
    5455</mt:else>