File Coverage

blib/lib/Net/Correios.pm

Criterion	Covered	Total	%
statement	52	62	83.8
branch	9	22	40.9
condition	6	17	35.2
subroutine	14	14	100.0
pod	3	5	60.0
total	84	120	70.0

use strict;
use warnings;

use HTTP::Tiny;
use MIME::Base64 ();
use Carp         ();
use Scalar::Util ();
use JSON         ();

$Carp::Internal{ 'Net::Correios' }++;

package Net::Correios;

our $VERSION = '0.003';

my %libs = (
  token        => 'Token',
  cep          => 'CEP',
  sro          => 'SRO',
  preco        => 'Preco',
  prazo        => 'Prazo',
  empresas     => 'Empresas',
  prepostagens => 'Prepostagens',
  faturas      => 'Faturas',
  agencias     => 'Agencias',
  manifestacao => 'Manifestacao',
);

# create lazy accessors.
foreach my $method (keys %libs) {
    $Carp::Internal{ 'Net::Correios::' . $libs{$method} }++;
    my $sub = sub {
        my ($self, %args) = @_;
        my $internal_key = 'endpoint_' . $method;
        if (!$self->{$internal_key}) {
            my $module = 'Net/Correios/' . $libs{$method} . '.pm';
            require $module;
            my $class = 'Net::Correios::' . $libs{$method};
            $self->{$internal_key} = $class->new( $self );
        }
        return $self->{$internal_key};
    };
    { no strict 'refs';
      *{"Net\::Correios\::$method"} = $sub;
    }
}

sub new {
    my ($class, %args) = @_;
    Carp::croak 'Net::Correios::new - "username" and "password" are required'
        unless $args{username} && $args{password};
    my $auth_basic = MIME::Base64::encode_base64($args{username} . ':' . $args{password}, '');
    return bless {
        contrato => $args{contrato},
        cartao => $args{cartao},
        sandbox => !!$args{sandbox},
        base_url => 'https://api' . (('hom')x!!$args{sandbox}) . '.correios.com.br/',
        auth_basic => $auth_basic,
        agent => HTTP::Tiny->new(
            default_headers => {
                'Accept' => 'application/json',
                'Content-Type' => 'application/json',
            },
            verify_SSL => 1,
            timeout => $args{timeout} || 5,
        ),
    }, $class;
}

sub is_sandbox { $_[0]->{sandbox} }

sub access_token {
    my ($self, $token_type) = @_;
    die 'token deve ser "cartao", "contrato" ou undef'
        if defined $token_type && $token_type ne 'cartao' && $token_type ne 'contrato';

    my $storage_key = 'token' . (defined $token_type ? '_' . $token_type : '');
    return $self->{$storage_key} if defined $self->{$storage_key};

    my $token_res = $self->token->autentica(
        (defined $token_type ? ($token_type => $self->{$token_type}) : ())
    );

    $self->{$storage_key} = $token_res->{token};
    if ($token_res->{cartaoPostagem} && (!$self->{cartao} || $self->{cartao} eq $token_res->{cartaoPostagem}{numero})) {
        $self->{dr} = $token_res->{cartaoPostagem}{dr};
        $self->{contrato} = $token_res->{cartaoPostagem}{contrato} if !$self->{contrato};
    }
    return $self->{$storage_key};
}

sub make_request {
    my ($self, $token_type, $method, $url, $args) = @_;
    $args = {} if !defined $args;
    $url = $self->{base_url} . $url;
    my $token = $self->access_token($token_type);
    $args->{headers}{Authorization} = 'Bearer ' . $token;
    my $res = $self->{agent}->request($method, $url, $args);
    return $res;
}

sub parse_response {
    my ($self, $res) = @_;
    if ($res->{success}) {
        my $data = JSON::decode_json($res->{content});
        return $data;
    }
    else {
        my $error = $res->{status} . ' ' . $res->{reason};
        $error .= ":\n" . $res->{content} if length $res->{content};
        $error .= "\n  " . $res->{url};
        Carp::croak($error);
    }
}

1;
__END__