File Coverage

blib/lib/Net/Flotum.pm

Criterion	Covered	Total	%
statement	73	74	98.6
branch	9	16	56.2
condition	9	21	42.8
subroutine	25	25	100.0
pod	0	2	0.0
total	116	138	84.0

package Net::Flotum;
use strict;
use 5.008_005;
our $VERSION = '0.09';

use warnings;
use utf8;
use Carp qw/croak confess/;
use Moo;
use namespace::clean;

use Net::Flotum::API::Charge;
use Net::Flotum::API::Customer;
use Net::Flotum::API::RequestHandler;

use Net::Flotum::Object::Customer;

has 'logger'    => ( is => 'ro', builder => '_build_logger',    lazy => 1 );
has 'requester' => ( is => 'ro', builder => '_build_requester', lazy => 1 );
has 'merchant_api_key' => ( is => 'rw', required => 1 );

has 'customer_api' => ( is => 'ro', builder => '_build_customer_api', lazy => 1 );
has 'charge_api'   => ( is => 'ro', builder => '_build_charge_api',   lazy => 1 );

sub _build_requester {
    Net::Flotum::API::RequestHandler->new;
}

sub _build_logger {
    require Net::Flotum::Logger::Log4perl;
    Net::Flotum::Logger::Log4perl->new->logger;
}

sub _build_customer_api {
    my ($self) = @_;
    Net::Flotum::API::Customer->new( flotum => $self, );
}

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

    Net::Flotum::API::Charge->new( flotum => $self );
}

sub load_customer {
    my ( $self, %opts ) = @_;

    my $cus;
    if ( exists $opts{id} ) {
        $cus = Net::Flotum::Object::Customer->new(
            flotum => $self,
            id     => $opts{id}
        );
        $cus->_load_from_id;
    }
    elsif ( exists $opts{remote_id} ) {
        $cus = Net::Flotum::Object::Customer->new(
            flotum => $self,
            id     => 'this workaround is embarrassed'
        );
        $cus->_load_from_remote_id( $opts{remote_id} );
    }
    else {
        croak 'missing parameter: `remote_id` or `id` is required';
    }

    return $cus;
}

sub new_customer {
    my ( $self, %opts ) = @_;

    my $customer_id = $self->customer_api->exec_new_customer(%opts);

    return Net::Flotum::Object::Customer->new(
        flotum => $self,
        %$customer_id
    );
}

sub _new_charge {
    my $self = shift;

    return $self->charge_api->exec_new_charge(@_);
}

sub _payment_charge {
    my $self = shift;

    return $self->charge_api->exec_payment_charge(@_);
}

sub _capture_charge {
    my $self = shift;

    return $self->charge_api->exec_capture_charge(@_);
}

sub _refund_charge {
    my $self = shift;

    return $self->charge_api->exec_refund_charge(@_);
}

sub _get_customer_data {
    my ( $self, %opts ) = @_;

    confess 'missing parameter: `remote_id` or `id` is required'
      unless ( exists $opts{remote_id} && defined $opts{remote_id} )
      || ( exists $opts{id} && defined $opts{id} );

    return $self->customer_api->exec_load_customer(%opts);

}

sub _get_customer_session_key {
    my ( $self, %opts ) = @_;

    confess 'missing parameter: `id` is required'
      unless ( exists $opts{id} && defined $opts{id} );

    return $self->customer_api->exec_get_customer_session(%opts)->{api_key};
}

sub _get_list_customer_credit_cards {
    my ( $self, %opts ) = @_;

    confess 'missing parameter: `id` is required'
      unless ( exists $opts{id} && defined $opts{id} );

    my $arr = $self->customer_api->exec_list_credit_cards(%opts)->{credit_cards};
    return wantarray ? @$arr : $arr;
}

sub _remove_customer_credit_cards {
    my ( $self, %opts ) = @_;

    confess 'missing parameter: `id` is required'
      unless ( exists $opts{id} && defined $opts{id} );
    confess 'missing parameter: `merchant_customer_id` is required'
      unless ( exists $opts{merchant_customer_id} && defined $opts{merchant_customer_id} );

    my $bool = $self->customer_api->exec_remove_credit_card(%opts);
    return $bool;
}

1;

__END__