File Coverage

blib/lib/Google/API/OAuth2/Client.pm

Criterion	Covered	Total	%
statement	67	98	68.3
branch	16	38	42.1
condition	2	2	100.0
subroutine	12	14	85.7
pod	9	9	100.0
total	106	161	65.8

package Google::API::OAuth2::Client;

use strict;
use warnings;
use URI;

sub new {
    my $class = shift;
    my ($param) = @_;
    for my $key (qw/auth_uri token_uri client_id client_secret/) {
        return unless $param->{$key};
    }
    unless (defined $param->{ua}) {
        $param->{ua} = $class->_new_ua;
    }
    unless (defined $param->{json_parser}) {
        $param->{json_parser} = $class->_new_json_parser;
    }
    bless { %$param }, $class;
}

sub new_from_client_secrets {
    my $class = shift;
    my ($file, $auth_doc) = @_;
    open my $fh, '<', $file
        or die "$file not found";
    my $content = do { local $/; <$fh> };
    close $fh;
    require JSON;
    my $json = JSON->new->decode($content);
    my ($client_type) = keys(%$json);
    $class->new({
        auth_uri => $json->{$client_type}->{auth_uri},
        token_uri => $json->{$client_type}->{token_uri},
        client_id => $json->{$client_type}->{client_id},
        client_secret => $json->{$client_type}->{client_secret},
        redirect_uri => @{$json->{$client_type}->{redirect_uris}}[0],
        auth_doc => $auth_doc,
    });
}

sub authorize_uri {
    my $self = shift;
    my ($response_type) = @_;
    $response_type ||= 'code';
    for my $key (qw/client_id redirect_uri/) {
        return unless $self->{$key};
    }
    my $authorize_uri = "$self->{auth_uri}?client_id=$self->{client_id}&redirect_uri=$self->{redirect_uri}&response_type=$response_type";
    if ($self->{auth_doc}) {
        my @scopes = keys %{$self->{auth_doc}{oauth2}{scopes}};
        $authorize_uri .= '&scope=' . join ' ', @scopes;
    }
    if ($self->{access_type}){
        $authorize_uri .= "&access_type=$self->{access_type}";
    }
    if ($self->{approval_prompt}){
        $authorize_uri .= "&approval_prompt=$self->{approval_prompt}";
    }
    return URI->new($authorize_uri)->as_string;
}

sub exchange {
    my $self = shift;
    my ($code) = @_;
    return unless $code;
    return unless $self->{auth_doc};
    for my $key (qw/client_id client_secret/) {
        return unless $self->{$key};
    }
    my @scopes = keys %{$self->{auth_doc}{oauth2}{scopes}};
    my $scopes = join ' ', @scopes;
    my @param = (
        client_id => $self->{client_id},
        client_secret => $self->{client_secret},
        redirect_uri => $self->{redirect_uri},
        code => $code,
        scope => $scopes,
        grant_type => 'authorization_code',
    );
    require HTTP::Request::Common;
    my $res = $self->{ua}->request(
        HTTP::Request::Common::POST(
            $self->{token_uri},
            Content_Type => 'application/x-www-form-urlencoded',
            Content => [@param]
        )
    );
    unless ($res->is_success) {
        return;
    }
    my $access_token = $self->{json_parser}->decode($res->content);
    $self->{token_obj} = $access_token;
    return $self->{token_obj};
}

sub refresh {
    my $self = shift;
    for my $key (qw/client_id client_secret token_obj/) {
        return unless $self->{$key};
    }
    my @param = (
        client_id => $self->{client_id},
        client_secret => $self->{client_secret},
        refresh_token => $self->{token_obj}{refresh_token},
        grant_type => 'refresh_token',
    );
    require HTTP::Request::Common;
    my $res = $self->{ua}->request(
        HTTP::Request::Common::POST(
            $self->{token_uri},
            Content_Type => 'application/x-www-form-urlencoded',
            Content => [@param]
        )
    );
    unless ($res->is_success) {
        return;
    }
    my $access_token = $self->{json_parser}->decode($res->content);
    unless ($access_token->{refresh_token}) {
        $access_token->{refresh_token} = $self->{token_obj}{refresh_token};
    }
    $self->{token_obj} = $access_token;
    return $self->{token_obj};
}

sub token_obj {
    my $self = shift;
    my ($token_obj) = @_;
    return $self->{token_obj} unless $token_obj;
    $self->{token_obj} = $token_obj;
}

sub token_type {
    my $self = shift;
    return unless $self->{token_obj};
    return $self->{token_obj}{token_type};
}

sub access_token {
    my $self = shift;
    return unless $self->{token_obj};
    return $self->{token_obj}{access_token};
}

sub auth_doc {
    my $self = shift;
    if (@_) {
        my ($doc) = @_;
        $self->{auth_doc} = $doc;
    }
    return $self->{auth_doc};
}

sub _new_ua {
    my $class = shift;
    require LWP::UserAgent;
    my $ua = LWP::UserAgent->new;
    return $ua;
}

sub _new_json_parser {
    my $class = shift;
    require JSON;
    my $parser = JSON->new;
    return $parser;
}

1;
__END__