File Coverage

blib/lib/Net/Mailboxlayer.pm

Criterion	Covered	Total	%
statement	36	86	41.8
branch	6	30	20.0
condition	0	15	0.0
subroutine	11	21	52.3
pod	12	12	100.0
total	65	164	39.6

package Net::Mailboxlayer;

use strict;
use warnings;

$Net::Mailboxlayer::VERSION = '0.003';

use URI::URL;
use LWP::UserAgent;
use Scalar::Util 'blessed';
use JSON::MaybeXS qw(JSON);

use Net::Mailboxlayer::Error;
use Net::Mailboxlayer::Response;

sub new
{
    my ($class, %props) = @_;

    # set defaults
    my $self = bless {
        _endpoint => 'https://apilayer.net/api/check',
        _smtp => 1,
        _format => 0,
        _catch_all => 0,
        _user_agent_opts => {},
        _user_agent => undef,
        _optional_querystring_parts => [qw(smtp format callback catch_all)],
        _json => JSON->new,
    }, $class;

    foreach my $prop (qw (endpoint access_key email_address smtp format callback catch_all user_agent_opts user_agent json_decoder))
    {
        next if not exists $props{$prop};
        $self->$prop($props{$prop});
    }
    return $self;
}

sub endpoint
{
    my ($self, $val) = @_;
    $self->{_endpoint} = $val if defined $val;
    return $self->{_endpoint};
}

sub access_key
{
    my ($self, $val) = @_;
    $self->{_access_key} = $val if defined $val;
    return $self->{_access_key};
}

sub email_address
{
    my ($self, $val) = @_;
    $self->{_email_address} = $val if defined $val;
    return $self->{_email_address};
}

sub smtp
{
    my ($self, $val) = @_;
    $self->{_smtp} = $val if defined $val;
    return $self->{_smtp};
}

sub format
{
    my ($self, $val) = @_;
    $self->{_format} = $val if defined $val;
    return $self->{_format};
}
sub callback
{
    my ($self, $val) = @_;
    $self->{_callback} = $val if defined $val;
    return $self->{_callback};
}

sub catch_all
{
    my ($self, $val) = @_;
    $self->{_catch_all} = $val if defined $val;
    return $self->{_catch_all};
}

sub user_agent_opts
{
    my ($self, $val) = @_;
    $self->{_user_agent_opts} = $val if defined $val;
    return $self->{_user_agent_opts};
}

sub user_agent
{
    my ($self, $val) = @_;

    if ($val and blessed $val and $val->can('get'))
    {
        $self->{_user_agent} = $val;
    }
    if (not $self->{_user_agent})
    {
        $self->{_user_agent} = LWP::UserAgent->new(%{$self->{_user_agent_opts}});
    }
    return $self->{_user_agent};
}

sub json_decoder
{
    my ($self, $val) = @_;

    if ($val and blessed $val and $val->can('decode'))
    {
        $self->{_json} = $val;
    }
    return $self->{_json};
}

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

    my $url = URI::URL->new($self->endpoint);

    my @parts = (
        access_key => $self->access_key,
        email => $self->email_address,
    );
    foreach my $part (@{$self->{_optional_querystring_parts}})
    {
        if ($self->$part)
        {
            push @parts, $part => $self->$part;
        }
    }

    $url->query_form(@parts);

    return $url;
}

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

    my $url = $self->_build_url;

    my $response = $self->user_agent->get($url);

    if ($response->is_error)
    {
        return Net::Mailboxlayer::Error->new(
            success => 0,
            error => {
                code => $response->code,
                type => $response->status_line,
                info => $response->message,
            },
        );
    }

    # todo: try catch here in case we have invalid json
    my $data = $self->json_decoder->decode($response->decoded_content);
    $data->{_response} = $response;

    if (exists $data->{success} and not $data->{success})
    {
        return Net::Mailboxlayer::Error->new(%{$data});
    }

    return Net::Mailboxlayer::Response->new(%{$data});
}

1;

__END__