phpman > perldoc > Flickr::API(3pm)

NAME
    Flickr::API - Perl interface to the Flickr API

SYNOPSIS
  Using OAuth to call a method not requiring authentication
      use Flickr::API;

      my $api = Flickr::API->new({
            'consumer_key'    => 'your_api_key',
            'consumer_secret' => 'your_app_secret',
        });

      my $response = $api->execute_method('flickr.test.echo', {
            'foo' => 'bar',
            'baz' => 'quux',
        });


      my $config_file = $HOME/saved-flickr.st;
      $api->export_storable_config($config_file);

  Non-OAuth method calling method not requiring authentication
      use Flickr::API;

      # key deprecated in favor of api_key
      # secret deprecated in favor of api_secret
      #
      my $api = Flickr::API->new({
            'api_key'    => 'your_api_key',
            'api_secret' => 'your_app_secret',
        });

      my $response = $api->execute_method('flickr.test.echo', {
            'foo' => 'bar',
            'baz' => 'quux',
        });

  Alternatively, Using OAuth for non-authenticated request
      use Flickr::API;
      use Flickr::API::Request;

      my $api = Flickr::API->new({'consumer_key' => 'your_api_key','consumer_secret' => 'your_app_secret'});

      my $request = Flickr::API::Request->new({
            'method' => 'flickr.test.echo',
            'args' => {},
        });

      my $response = $api->execute_request($request);

  Authenticate an OAuth API Object starting with saved configuration
      use Flickr::API;
      use Term::ReadLine;

      my $config_file = "$ENV{HOME}/saved-flickr.st";
      my $term   = Term::ReadLine->new('Testing Flickr::API');
      $term->ornaments(0);

      my $api = Flickr::API->import_storable_config($config_file);

      my $rt_rc =  $api->oauth_request_token( { 'callback' => 'https://127.0.0.1/' } );

      my %request_token;
      if ( $rt_rc eq 'ok' ) {

          my $uri = $api->oauth_authorize_uri({ 'perms' => 'read' });

          my $prompt = "\n\n$uri\n\n" .
              "Copy the above url to a browser, and authenticate with Flickr\n" .
              "Press [ENTER] once you get the redirect: ";
          my $input = $term->readline($prompt);

          $prompt = "\n\nCopy the redirect URL from your browser and enter it\nHere: ";
          $input = $term->readline($prompt);

          chomp($input);

          my ($callback_returned,$token_received) = split(/\?/,$input);
          my (@parms) = split(/\&/,$token_received);
          foreach my $pair (@parms) {

              my ($key,$val) = split(/=/,$pair);
              $key =~ s/oauth_//;
              $request_token{$key}=$val;

          }
      }

      my $ac_rc = $api->oauth_access_token(\%request_token);
      if ( $ac_rc eq 'ok' ) {

          $api->export_storable_config($config_file);

          my $response = $api->execute_method('flickr.auth.oauth.checkToken');
          my $hash_ref = $response->as_hash();

          $response    = $api->execute_method('flickr.prefs.getPrivacy');
          my $rsp_node = $response->as_tree();
      }

  The OAuth authorization uri will look something like:
      https://api.flickr.com/services/oauth/authorize?oauth_token=12345678901234567-890abcdefedcba98&perms=read

  The callback is called with a token and verifier such as:
      https://127.0.0.1/?oauth_token=12345678901234567-890abcdefedcba98&oauth_verifier=cafe12345678feed

DESCRIPTION
    An interface for using the Flickr API.

    "Flickr::API" is a subclass of LWP::UserAgent, so all of the various proxy, request limits,
    caching, etc are available. "Flickr::API" can instantiate using either the Flickr Authentication
    (deprecated) or the OAuth Authentication. OAuth is handled using Net::OAuth.

SUBROUTINES/METHODS
    "new({ opt => 'value', ... })"
        Returns as new Flickr::API object. The options are as follows:

        either "api_key" for the Flickr auth or "consumer_key" for OAuth
            Your API key (one or the other form is required)

        either "api_secret" for the Flickr auth or "consumer_secret" for OAuth
            Your API key's secret (the one matching the api_key/consumer_key is required)

        "rest_uri" & "auth_uri"
            Override the URIs used for contacting the API.

        "lwpobj"
            Base the "Flickr::API" on this object, instead of creating a new instance of
            LWP::UserAgent. This is useful for using the features of e.g. LWP::UserAgent::Cached.

        "unicode"
            This flag controls whether Flickr::API expects you to pass UTF-8 bytes (unicode=0, the
            default) or actual unicode strings (unicode=1) in the request.

        "nonce", "timestamp", "request_method", "signature_method", "request_url"
            These values are used by Net::OAuth to assemble and sign OAuth *consumer* request Flickr
            API calls. The defaults are usually fine.

        "callback"
            The callback is used in oauth authentication. When Flickr authorizes you, it returns the
            access token and access token secret in a callback URL. This defaults to
            https://127.0.0.1/

        "token" and "token_secret"
            These values are used by Net::OAuth to assemble and sign OAuth *protected resource*
            request Flickr API calls.

    "execute_method($method, $args)"
        Constructs a Flickr::API::Request object and executes it, returning a Flickr::API::Response
        object.

    "execute_request($request)"
        Executes a Flickr::API::Request object, returning a Flickr::API::Response object. Calls are
        signed if a secret was specified when creating the Flickr::API object.

    "request_auth_url($perms,$frob)"
        Returns a URI object representing the URL that an application must redirect a user to for
        approving an authentication token.

        $perms must be read, write, or delete.

        For web-based applications *$frob* is an optional parameter.

        Returns undef if a secret was not specified when creating the "Flickr::API" object.

    "export_config([$type,$params])"
        Returns a hash of all or part of the persistent parts of the Flickr::API object with
        additional behaviors for Flickr::API objects using OAuth.

        oauth message type: one of "Consumer", "Protected Resource", "Request Token", "Authorize
        User" or "Access Token"
            This is one of the the message type that Net::OAuth handles. Message type is optional.

        oauth parameter set: "message" or "API" or undef.
            Net::OAuth will return message params, api params or all params depending on what is
            requested. All params is the default.

        If the Flickr::API object identifies as Flickr original authentication, return a hashref

          $VAR1 = {
                    'frob' => '12332112332112300-feedabcde123456c-1234567',
                    'api_key' => 'cafefeedbeef13579246801234567890',
                    'api_secret' => 'beef321432154321',
                    'token' => '97531086421234567-cafe123456789abc'
                  };

        or the subset thereof depending on what has been used by the API. If the older form of
        key/secret was used, the constructor will change these to the api_key/api_secret forms.

        If the API object identifies as OAuth authentication, and "message type" is specified, then
        export_config will return a hash of the OAuth parameters for the specified Net::OAuth
        message type. Further, if parameter is specified, then export_config returns either either
        the set of message parameters or api parameters for the message type. If parameter is not
        specified then both parameter type are returned. For example:

          my %config = $api->export_config('protected resource');

        or

          my %config = $api->export_config('protected resource','message');

        When export_config is called without arguments, then it returns the OAuth portion of the
        Flickr::API object. If present the Net::OAuth *Request Token* and *Access Token* objects are
        also included.

          VAR1 = {
                    'access_token' => bless( {
                                               'extra_params' => {
                                                                   'fullname' => 'Louis',
                                                                   'user_nsid' => '12345678@N00',
                                                                   'username' => 'meanameicallmyself'
                                                                 },
                                               'from_hash' => 1,
                                               'token' => '12345678901234567-cafe123098765432',
                                               'token_secret' => 'eebeef000fedbca1'
                                             }, 'Net::OAuth::AccessTokenResponse' ),
                    'callback' => 'https://127.0.0.1',
                    'consumer_key' => 'cafefeedbeef13579246801234567890',
                    'consumer_secret' => 'fedcba9876543210',
                    'nonce' => '917fa882fa7babd5a1b7702e7d19502a',
                    'request_method' => 'GET',
                    'request_url' => 'https://api.flickr.com/services/rest/',
                    'signature_method' => 'HMAC-SHA1',
                    'timestamp' => 1436129308,
                    'token' => '12345678901234567-cafe123098765432',
                    'token_secret' => 'eebeef000fedbca1',
                    'version' => '1.0'
                  };

          my %config = $api->export_config();

    This method can be used to extract and save the API parameters for future use.

    "export_storable_config(filename)"
        This method wraps export_config with a file open and storable store_fd to add some
        persistence to a Flickr::API object.

    "import_storable_config(filename)"
        This method retrieves a storable config of a Flickr::API object and revivifies the object.

    "get_oauth_request_type()"
        Returns the oauth request type in the Flickr::API object. Some Flickr methods will require a
        "protected resource" request type and others a simple "consumer" request type.

    "oauth_request_token(\%args)"
        Assembles, signs, and makes the OAuth Request Token call, and if successful stores the
        Net::OAuth *Request Token* in the Flickr::API object.

        The required parameters are:

        "consumer_key"
            Your API Key

        "consumer_secret"
            Your API Key's secret

        "request_method"
            The URI Method: GET or POST

        "request_url"
            Defaults to: <https://api.flickr.com/services/oauth/request_token>

    "flickr_access_token"
        The required parameters are:

        "key"

    "oauth_access_token(\%args)"
        Assembles, signs, and makes the OAuth Access Token call, and if successful stores the
        Net::OAuth *Access Token* in the Flickr::API object.

        The required parameters are:

        "consumer_key"
            Your API Key

        "consumer_secret"
            Your API Key's secret

        "request_method"
            The URI Method: GET or POST

        "request_url"
            Defaults to: <https://api.flickr.com/services/oauth/access_token>

        "token_secret"
            The request token secret from the Net::OAuth *Request Token* object returned from the
            *oauth_request_token* call.

    "oauth_authorize_uri(\%args)"
        Returns a URI object representing the URL that an application must redirect a user to for
        approving a request token.

        "perms"
            Permission the application is requesting, one of read, write, or delete, defaults to
            read.

    "is_oauth"
        Returns 1 if the Flickr::API object is OAuth flavored, 0 otherwise.

AUTHOR
    Cal Henderson, <cal AT iamcal.com>

    Auth API patches provided by Aaron Straup Cope

    Subclassing patch from AHP

    OAuth patches and additions Louis B. Moore <lbmoore AT cpan.org>

LICENSE AND COPYRIGHT
    Copyright (C) 2004-2013, Cal Henderson, <cal AT iamcal.com>

    OAuth patches and additions Copyright (C) 2014-2016 Louis B. Moore <lbmoore AT cpan.org>

    This program is released under the Artistic License 2.0 by The Perl Foundation.

SEE ALSO
    Flickr::API::Request, Flickr::API::Response, Net::OAuth, XML::Parser::Lite, Flickr
    <http://www.flickr.com/>, <http://www.flickr.com/services/api/>
    <https://www.flickr.com/services/api/auth.oauth.html>
    <https://github.com/iamcal/perl-Flickr-API>