File Coverage

blib/lib/Net/PayPal/Lite.pm

Criterion	Covered	Total	%
statement	21	131	16.0
branch	0	58	0.0
condition	0	40	0.0
subroutine	7	27	25.9
pod	9	13	69.2
total	37	269	13.7

package Net::PayPal::Lite;
use strict;
use warnings;

use JSON;
use Carp 'croak';
use LWP::UserAgent;
use HTTP::Headers;
use HTTP::Request;

our $VERSION = '0.01';

my $json = JSON->new->allow_nonref;

sub live {
    my $self = shift;
    return ! $self->sandbox( scalar @_ ? !$_[0] : () );
}

sub sandbox {
    my $self = shift;
    if (scalar @_) {
        $self->{sandbox} = !! $_[0];
    }
    return $self->{sandbox};
}

sub endpoint {
    my ($self) = @_;
    $self->sandbox ? 'https://api.sandbox.paypal.com'
                   : 'https://api.paypal.com';
}

sub new {
    my $class = shift;
    my $args = (ref $_[0] ? $_[0] : {@_});

    croak 'please provide a client_id and a secret'
        unless $args->{client_id} and $args->{secret};

    croak 'passing both sandbox and live attributes is not allowed'
        if exists $args->{sandbox} and exists $args->{live};

    croak '"cache_transform" hashref must have "in" and "out" subrefs'
        if exists $args->{cache_transform}
          && (ref $args->{cache_transform} ne 'HASH'
               || !exists $args->{cache_transform}{in}
               || !exists $args->{cache_transform}{out}
               || ref $args->{cache_transform}{in}  ne 'CODE'
               || ref $args->{cache_transform}{out} ne 'CODE'
           );

    return bless {
        client_id        => $args->{client_id},
        secret           => $args->{secret},
        user_agent       => $args->{user_agent} || _create_ua(),
        cache_transform  => $args->{cache_transform},
        cache            => $args->{cache}
                         || _create_cache($args->{cache_dir}),
        sandbox          => (  exists $args->{sandbox} ?  $args->{sandbox}
                             : exists $args->{live}    ? !$args->{live}
                             : 1
                         ),
    }, $class;
}

sub access_token {
    my $self = shift;

    if (@_) {
        my ($token, $expiration) = @_;
        $self->_set_cached_access_token($token, $expiration || () );
        return $token;
    }
    elsif ( my $token = $self->_get_cached_access_token ) {
        return $token;
    }
    else {
        my ($token ,$expiration) = $self->_get_access_token_from_paypal;
        $self->_set_cached_access_token($token, $expiration);
        return $token;
    }
}


sub _get_access_token_from_paypal {
    my ($self) = @_;

    my $header = HTTP::Headers->new(
        'Content-Type'    => 'application/x-www-form-urlencoded',
        'Accept'          => 'application/json',
        'Accept-Language' => 'en_US'
    );

    $header->authorization_basic( $self->{client_id}, $self->{secret} );

    my $req = HTTP::Request->new(
        'POST' => $self->endpoint . '/v1/oauth2/token',
        $header,
        'grant_type=client_credentials'
    );

    my $res = $self->{user_agent}->request($req);

    croak 'Authorization failed: ' . $res->status_line . ', ' . $res->content
        unless $res->is_success;

    my $res_hash = _json_decode( $res->content );

    return ($res_hash->{access_token}, $res_hash->{expires_in});
}

sub _set_cached_access_token {
    my ($self, $token, $expiration) = @_;

    $token = $self->{cache_transform}{in}->($token)
        if $self->{cache_transform};

    $self->{cache}->set( $self->{client_id}, $token, $expiration );
}

sub _get_cached_access_token {
    my ($self) = @_;

    my $token = $self->{cache}->get( $self->{client_id} );

    $token = $self->{cache_transform}{out}->($token)
        if $self->{cache_transform};

    return $token;
}

sub _create_cache {
    my ($cache_root) = @_;
    require Cache::FileCache;
    return Cache::FileCache->new({
        namespace  => 'PayPalAPI',
        ($cache_root ? (cache_root => $cache_root) : ()),
    });
}

sub _create_ua {
    require LWP::UserAgent;
    return LWP::UserAgent->new( agent => "Net-PayPal-Lite/$VERSION" );
}

sub _json_decode {
    my $text = shift;
    my $hashref;
    eval { $hashref = $json->decode($text); };

    if ( my $error = $@ ) {
        croak "_json_decode(): cannot decode $text: $error";
    }
    return $hashref;
}

sub _json_encode {
    my $hashref = shift;
    return $json->encode($hashref);
}

sub rest {
    my ($self, $method, $path, $json) = @_;

    my $target_uri = $self->endpoint . $path;
    my $token = $self->access_token;

    my $req = HTTP::Request->new(
        $method => $target_uri,
        [
            'Content-Type'  => 'application/json',
            'Authorization' => "Bearer $token"
        ]
    );

    if ($json) {
        $json = _json_encode($json) if ref $json;
        $req->content($json);
    }

    my $res = $self->{user_agent}->request($req);

    if ($res->is_success) {
        return _json_decode( $res->content );
    }
    else {
        if ( my $content = $res->content ) {
            my $error = _json_decode( $res->content );
            $self->error( $res->content );
        }
        else {
            $self->error( $res->status_line );
        }
        return undef;
    }
}

sub cc_payment {
    my $self = shift;
    my ($data) = @_;

    foreach my $field (qw/cc_number cc_type cc_expire_month cc_expire_year/) {
        unless ( $data->{$field} ) {
            croak "payment(): $field is a required field";
        }
    }

    my %credit_card = (
        number       => $data->{cc_number},
        type         => $data->{cc_type},
        expire_month => $data->{cc_expire_month},
        expire_year  => $data->{cc_expire_year}
    );

    foreach my $field (qw/first_name last_name billing_address/) {
        if ( $data->{$field} ) {
            $credit_card{$field} = $data->{$field};
        }
    }

    my $request_hash = {
        intent => 'sale',
        payer  => {
            payment_method      => 'credit_card',
            funding_instruments => [ { credit_card => \%credit_card } ]
        },
        transactions => [
            {
                amount => {
                    total    => $data->{amount},
                    currency => $data->{currency} || 'USD'
                },
            }
        ]
    };

    if ( $data->{redirect_urls} ) {
        $request_hash->{redirect_urls} = $data->{redirect_urls};
    }

    return $self->rest( 'POST', '/v1/payments/payment', _json_encode($request_hash) );
}

sub stored_cc_payment {
    my $self = shift;
    my ($data) = @_;

    unless ( $data->{id} ) {
        croak 'stored_cc_payment(): "id" is missing';
    }

    my $request_hash = {
        intent => 'sale',
        payer  => {
            payment_method      => 'credit_card',
            funding_instruments => [ { credit_card_token => { credit_card_id => $data->{id} } } ]
        },
        transactions => [
            {
                amount => {
                    total    => $data->{amount},
                    currency => $data->{currency} || 'USD'
                },
            }
        ]
    };

    if ( $data->{redirect_urls} ) {
        $request_hash->{redirect_urls} = $data->{redirect_urls};
    }

    return $self->rest( 'POST', '/v1/payments/payment', _json_encode($request_hash) );
}

sub get_payment {
    my $self = shift;
    my ($id) = @_;

    unless ($id) {
        croak 'get_payment(): Invalid Payment ID';
    }

    return $self->rest( 'GET', "/v1/payments/payment/$id" );
}

sub get_payments {
    my $self = shift;

    return $self->rest( 'GET', '/v1/payments/payment' );
}

sub store_cc {
    my $self = shift;
    my ($data) = @_;

    my %credit_card = (
        number       => $data->{number}       || $data->{cc_number},
        type         => $data->{type}         || $data->{cc_type},
        expire_month => $data->{expire_month} || $data->{cc_expire_month},
        expire_year  => $data->{expire_year}  || $data->{cc_expire_year}
    );

    if ( my $cvv2 = $data->{cvv2} || $data->{cc_cvv2} ) {
        $credit_card{cvv2} = $cvv2;
    }

    foreach my $field (qw/first_name last_name billing_address/) {
        if ( $data->{$field} ) {
            $credit_card{$field} = $data->{$field};
        }
    }
    return $self->rest( 'POST', '/v1/vault/credit-card', _json_encode( \%credit_card ) );
}

sub get_cc {
    my $self = shift;
    my ($id) = @_;
    return $self->rest( 'GET', "/v1/vault/credit-card/$id" );
}

sub error {
    my ($self, $message) = @_;
    return $self->{last_error} unless $message;
    return $self->{last_error} = $message
}

1;
__END__