File Coverage

blib/lib/Net/Flotum.pm

Criterion	Covered	Total	%
statement	78	79	98.7
branch	12	20	60.0
condition	11	24	45.8
subroutine	27	27	100.0
pod	0	2	0.0
total	128	152	84.2

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

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 Log::Any;
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 {
    Log::Any->get_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 $lazy = 1 if exists $opts{lazy} && $opts{lazy};
    my $cus;
    if ( exists $opts{id} ) {
        $cus = Net::Flotum::Object::Customer->new(
            flotum => $self,
            id     => $opts{id}
        );
        $cus->_load_from_id unless $lazy;
    }
    elsif ( exists $opts{remote_id} ) {
        $cus = Net::Flotum::Object::Customer->new(
            flotum => $self,
            id     => '_ID_IS_REQUIRED_'
        );
        $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 _update_customer {
    my $self = shift;
    return $self->customer_api->exec_update_customer(@_);
}

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__