File Coverage

blib/lib/WWW/BigDoor.pm

Criterion	Covered	Total	%
statement	98	99	98.9
branch	25	28	89.2
condition	14	20	70.0
subroutine	19	19	100.0
pod	4	4	100.0
total	160	170	94.1

package WWW::BigDoor;

use warnings;
use strict;

use Carp;
use Data::Dumper;
use Digest::SHA qw(sha256_hex);
use JSON;
use REST::Client;
use UUID::Tiny;

#use Smart::Comments -ENV;

use base qw(Class::Accessor);

use version; our $VERSION = qv( '0.1.1' );

BEGIN {
    foreach my $method ( qw(GET POST PUT DELETE) ) {
        no strict 'refs';    ## no critic (ProhibitNoStrict)

        #my $full_method_name = __PACKAGE__.'::'.$method;
        ## full method name: $full_method_name
        *{__PACKAGE__ . '::' . $method} = sub {
            my $response_body = do_request( shift, $method, @_ );

            my $decoded_response_body =
              $response_body && $response_body ne q{}
              ? decode_json( $response_body )
              : undef;       # TODO test for response_body eq q{}
            ## decoded_response_body: $decoded_response_body

            return $decoded_response_body;
          }
    }
}

__PACKAGE__->follow_best_practice;
__PACKAGE__->mk_accessors(
    qw(app_secret app_key api_host base_url request_result response_code response_content) );

sub new {

    my ( $class, $app_secret, $app_key, $api_host ) = @_;

    my $self = {};

    bless( $self, $class );

    ### check: defined $app_secret
    ### check: defined $app_key

    $self->set_app_secret( $app_secret );   # TODO test for empty or undefined app_secret or app_key
    $self->set_app_key( $app_key );
    $self->set_api_host( $api_host || 'http://api.bigdoor.com' );    # TODO test for empty $api_host
    $self->set_base_url( sprintf "/api/publisher/%s", $app_key );

    return $self;
}

sub do_request {
    my ( $self, $method, $endpoint, $params, $payload ) = @_;

    my $rc = REST::Client->new( {host => $self->get_api_host} );

    my $url = $self->get_base_url . '/' . $endpoint;

    ## method: $method
    ## url: $url

    my $par = defined $params  ? {%{$params}}  : undef;
    my $pay = defined $payload ? {%{$payload}} : undef;

    ( $par, $pay ) = $self->_sign_request( $method, $url, $par, $pay );

    ### check: defined $par
    # should be always defined by _sign_request
    my $args = $rc->buildQuery( $par );

    ## args: $args
    ## payload: Dumper($pay)

    my $headers = {
        'User-Agent'   => sprintf( 'BigDoorKit-Perl/%s', $VERSION ),
        'Content-Type' => 'application/x-www-form-urlencoded',
    };

    my $post_body = q{};

    if ( defined $pay ) {
        require URI;
        my $uri_encoded = URI->new( 'http:' );
        $uri_encoded->query_form( $pay );
        $post_body = $uri_encoded->query;

        ## post_body: $post_body
    }

    ### URL: $url . $args
    my $result = $rc->request( $method, $url . $args, $post_body, $headers );

    $self->set_request_result( $result );
    $self->set_response_code( $result->responseCode );
    $self->set_response_content( $result->responseContent );

    ### check: defined $result
    return unless defined $result;

    ### result: Dumper($result->{_res})
    ### response code: $result->responseCode()
    ### check: $result->responseCode < 300
    return if $result->responseCode >= 300;

    ## response content: $result->responseContent()
    ## response headers: Dumper($result->responseHeaders())

    my $response_body = $result->responseContent();
    ### check: defined $response_body
    ### response_body: $response_body

    return $response_body;

} ## end sub do_request

sub _sign_request {
    my ( $self, $method, $url, $params, $payload ) = @_;

    # FIXME use content copy
    my $is_postish = $method =~ /^(POST)|(PUT)$/ix;

    if ( $is_postish && exists $payload->{'time'} ) {
        $params->{'time'} = $payload->{'time'};
    }
    unless ( exists $params->{'time'} ) {
        $params->{'time'} = time;
    }
    if ( $is_postish && !exists $payload->{'time'} ) {
        $payload->{'time'} = $params->{'time'};
    }
    if ( $is_postish && !exists $payload->{'token'} ) {
        $payload->{'token'} = $self->generate_token();
    }
    if ( $method =~ /^DELETE$/ix && !exists $params->{'delete_token'} ) {
        $params->{'delete_token'} = $self->generate_token();
    }

    $params->{'sig'} = $self->generate_signature( $url, $params, $payload );

    ### check: defined $params

    return ( $params, $payload );
} ## end sub _sign_request

sub _flatten_params {
    my ( $params ) = @_;

    my $result = q{};

    foreach my $k ( sort keys %{$params} ) {
        next if $k eq 'sig' || $k eq 'format';
        $result .= sprintf '%s%s', $k, $params->{$k};
    }
    return $result;
}

sub generate_token {
    return unpack( "H*", create_UUID( UUID_V4 ) );
}

sub generate_signature {
    my ( $self, $url, $params, $payload ) = @_;

    my $signature = $url;

    $signature .= _flatten_params( $params )  if defined $params;
    $signature .= _flatten_params( $payload ) if defined $payload;

    $signature .= $self->get_app_secret();

    ### signature: $signature

    return sha256_hex( $signature );
}

1;    # Magic true value required at end of module
__END__