File Coverage

blib/lib/neverbounce.pm

Criterion	Covered	Total	%
statement	26	224	11.6
branch	0	88	0.0
condition	0	81	0.0
subroutine	9	19	47.3
pod	0	7	0.0
total	35	419	8.3

package neverbounce;

use 5.006;
use strict;
use warnings;
use vars qw($AUTOLOAD $NB_API_VERSION %result_details %status_code_des);
use Data::Dumper;
use Convert::Base64;
use HTTP::Request::Common;
use LWP::UserAgent;
use JSON;
require Exporter;
$NB_API_VERSION = '3.1';
our $VERSION    = '0.02';
our @ISA        = qw(Exporter);
our @EXPORT_OK  = qw();
%result_details = (
    0   =>  'No additional details',
    1   =>  'Provided email failed the syntax check'
);
%status_code_des= (
    0   =>  'Request has been received but has not started idexing',
    1   =>  'List is indexing and deduping',
    2   =>  'List is awaiting user input (Typically skipped for lists submitted via API)',
    3   =>  'List is being processed',
    4   =>  'List has completed verification',
    5   =>  'List has failed'
);
sub new {
    my $class = shift;
    my $self = bless {}, $class;
    my %hash = @_;
    my $temp = $self->_initialize(@_);
    if($temp) {
        return $self;
    } else {
        return;
    }
}
sub _initialize {
    my $self = shift;
    my %hash = @_;
    if (exists($hash{api_username})) {
        $self->{api_username} = $hash{api_username};
    } else {
        return (resp_status=>'error',data => {error => 'mandatory_value_missing',error_description => "The value for 'api_username' is missing"},request_data => '');
    }
    if (exists($hash{api_secret_key})) {
        $self->{api_secret_key} = $hash{api_secret_key};
    } else {
        return (resp_status=>'error',data => {error => 'mandatory_value_missing',error_description => "The value for 'api_secret_key' is missing"},request_data => '');
    }
    $self->{authorization} = encode_base64($self->{api_username}.':'.$self->{api_secret_key});
    my $req;
    $req=POST(
        "https://api.neverbounce.com/v3/access_token",
        Content_Type => 'form-data',
        Content      =>[
            grant_type  =>  'client_credentials',
            scope       =>  'basic user'
        ]
    );
    my $ua=LWP::UserAgent->new();
    $ua->ssl_opts( "verify_hostname" => 0 );
    $ua->agent('Mozilla/5.0');
    $ua->default_header("Authorization"=>"Basic ".$self->{authorization});
    my $result=$ua->request($req);
    if($result->is_success && $result->{_content} ne '') {
        my $response=decode_json($result->{_content});
        if(defined($response->{error}) || (defined($response->{success}) && $response->{success} ne 1)) {
            my %response_hash = %{$response};
            my %error_data = $self->nb_error(%response_hash);
            die Dumper(\%error_data);
        } else {
            $self->{access_token}   = $response->{access_token};
            $self->{expires_in}     = $response->{expires_in};
            $self->{token_type}     = $response->{token_type};
            $self->{scope}          = $response->{scope};
        }
    } else {
        my $msg=qq{Processing terminated due to failure in request to neverbounce.com};
        if($result->is_success && $result->{_content} eq '') {
            $msg=qq{Process terminated since there is no respone data from neverbounce.com};
            print STDERR $msg."\n\n".Dumper($result);
        } else {
            print STDERR $msg."\n\n".Dumper($result);
        }
        return 0;
    }
}
sub nb_verify_email {
    my $self = shift;
    my %hash = @_;
    if (exists($hash{email})) {
        $self->{email} = $hash{email};
    } else {
        return (resp_status=>'error',data => {error => 'mandatory_value_missing',error_description => "The value for 'email' is missing. Please provide email address to make verification."},request_data => '');
    }
    my $req;
    $req=POST(
        "https://api.neverbounce.com/v3/single?access_token=".$self->{access_token},
        Content_Type => 'form-data',
        Content      =>[
            email           =>  $self->{email}
        ]
    );
    my $ua=LWP::UserAgent->new();
    $ua->ssl_opts( "verify_hostname" => 0 );
    $ua->agent('Mozilla/5.0');
    my $result=$ua->request($req);
    if($result->is_success && $result->{_content} ne '') {
        my $response=decode_json($result->{_content});
        if(defined($response->{error}) || (defined($response->{success}) && $response->{success} ne 1)) {
            my %response_hash = %{$response};
            my %error_data = $self->nb_error(%response_hash);
            $error_data{request_data} = Dumper($result);
            return %error_data;
        } else {
            my %response_data = (
                resp_status     =>  'success',
                data            =>  {
                    result_code                 =>  $response->{result},
                    result_text_code            =>  $self->nb_result_code(result_code=>$response->{result},response_type=>'text_code'),
                    result_description          =>  $self->nb_result_code(result_code=>$response->{result},response_type=>'description'),
                    result_safe_to_send         =>  $self->nb_result_code(result_code=>$response->{result},response_type=>'safe_to_send'),
                    result_details_code         =>  $response->{result_details},
                    result_details_description  =>  $result_details{$response->{result_details}},
                    neverbounce_execution_time  =>  $response->{execution_time}
                },
                request_data    => Dumper($result)
            );
            return %response_data;
        }
    } else {
        my $msg=qq{Processing terminated due to failure in request to neverbounce.com};
        if($result->is_success && $result->{_content} eq '') {
            $msg=qq{Process terminated since there is no respone data from neverbounce.com};
        }
        return (resp_status=>'error',data => {error => 'Connection Error',error_description => $msg},request_data => Dumper($result));
    }
}
sub nb_email_list_batch_send {
    my $self = shift;
    my %hash = @_;
    $self->{input_location} = ($hash{input_location} eq '1')?$hash{input_location}:'0';
    if (exists($hash{input})) {
        $self->{input} = $hash{input};
    } else {
        return (resp_status=>'error',data => {error => 'mandatory_value_missing',error_description => "The value for 'input' is missing. Expected value: (If 'input_location' = 0, then 'input' should be the URL pointed to file which contain email list. If 'input_location' = 1, then 'input' should be URL encoded string of the contents of email list.)"},request_data => '');
    }
    if (exists($hash{filename})) {
        $self->{filename} = $hash{filename};
    }
    my $req;
    $req=POST(
        "https://api.neverbounce.com/v3/bulk?access_token=".$self->{access_token},
        Content_Type => 'form-data',
        Content      => [
            input_location  =>  $self->{input_location},
            input           =>  $self->{input},
            filename        =>  defined($self->{filename})?$self->{filename}:''
        ]
    );
    my $ua=LWP::UserAgent->new();
    $ua->ssl_opts( "verify_hostname" => 0 );
    $ua->agent('Mozilla/5.0');
    my $result=$ua->request($req);
    if($result->is_success && $result->{_content} ne '') {
        my $response=decode_json($result->{_content});
        if(defined($response->{error}) || (defined($response->{success}) && $response->{success} ne 1)) {
            my %response_hash = %{$response};
            my %error_data = $self->nb_error(%response_hash);
            $error_data{request_data} = Dumper($result);
            return %error_data;
        } else {
            my %response_data = (
                resp_status     =>  'success',
                data            =>  {
                    job_status                  =>  $response->{job_status},
                    job_id                      =>  $response->{job_id},
                    neverbounce_execution_time  =>  $response->{execution_time}
                },
                request_data    => Dumper($result)
            );
            return %response_data;
        }
    } else {
        my $msg=qq{Processing terminated due to failure in request to neverbounce.com};
        if($result->is_success && $result->{_content} eq '') {
            $msg=qq{Process terminated since there is no respone data from neverbounce.com};
        }
        return (resp_status=>'error',data => {error => 'Connection Error',error_description => $msg},request_data => Dumper($result));
    }
}
sub nb_email_list_batch_check {
    my $self = shift;
    my %hash = @_;
    if (exists($hash{job_id})) {
        $self->{job_id} = $hash{job_id};
    } else {
        return (resp_status=>'error',data => {error => 'mandatory_value_missing',error_description => "The value for 'job_id' is missing."},request_data => '');
    }
    my $req;
    $req=POST(
        "https://api.neverbounce.com/v3/status?access_token=".$self->{access_token},
        Content_Type => 'form-data',
        Content      =>[
            version =>  $NB_API_VERSION,
            job_id  =>  $self->{job_id}
        ]
    );
    my $ua=LWP::UserAgent->new();
    $ua->ssl_opts( "verify_hostname" => 0 );
    $ua->agent('Mozilla/5.0');
    my $result=$ua->request($req);
    if($result->is_success && $result->{_content} ne '') {
        my $response=decode_json($result->{_content});
        if(defined($response->{error}) || (defined($response->{success}) && $response->{success} ne 1)) {
            my %response_hash = %{$response};
            my %error_data = $self->nb_error(%response_hash);
            $error_data{request_data} = Dumper($result);
            return %error_data;
        } else {
            my %response_data = (
                resp_status     =>  'success',
                data            =>  {
                    status                      =>  $response->{status},
                    status_desc                 =>  $status_code_des{$response->{status}},
                    id                          =>  $response->{id},
                    type                        =>  $response->{type},
                    input_location              =>  $response->{input_location},
                    orig_name                   =>  $response->{orig_name},
                    created                     =>  $response->{created},
                    started                     =>  $response->{started},
                    finished                    =>  $response->{finished},
                    file_details                =>  $response->{file_details},
                    job_details                 =>  $response->{job_details},
                    neverbounce_execution_time  =>  $response->{execution_time},
                    stats                       =>  $response->{stats}
                },
                request_data    => Dumper($result)
            );
            return %response_data;
        }
    } else {
        my $msg=qq{Processing terminated due to failure in request to neverbounce.com};
        if($result->is_success && $result->{_content} eq '') {
            $msg=qq{Process terminated since there is no respone data from neverbounce.com};
        }
        return (resp_status=>'error',data => {error => 'Connection Error',error_description => $msg},request_data => Dumper($result));
    }
}
sub nb_email_list_batch_result {
    my $self = shift;
    my %hash = @_;
    if (exists($hash{job_id})) {
        $self->{job_id} = $hash{job_id};
    } else {
        return (resp_status=>'error',data => {error => 'mandatory_value_missing',error_description => "The value for 'job_id' is missing."},request_data => '');
    }
    my %check_status=$self->nb_email_list_batch_check(job_id=>$hash{job_id});
    if($check_status{resp_status} ne 'success'){
        return %check_status;
    } elsif($check_status{data}{status} ne '4') {
        my %error_data = (
            resp_status=>'error',
            data => $check_status{data},
            request_data => ''
        );
        $error_data{data}{error}='list_verification_completion_failure';
        $error_data{data}{error_description}=$check_status{data}{status_desc};
        return %error_data;
    }
    $self->{valids}     = ($hash{valids} eq '0')?$hash{valids}:'1';
    $self->{invalids}   = ($hash{invalids} eq '0')?$hash{invalids}:'1';
    $self->{catchall}   = ($hash{catchall} eq '0')?$hash{catchall}:'1';
    $self->{disposable} = ($hash{disposable} eq '0')?$hash{disposable}:'1';
    $self->{unknown}    = ($hash{unknown} eq '0')?$hash{unknown}:'1';
    $self->{duplicates} = ($hash{duplicates} eq '0')?$hash{duplicates}:'1';
    $self->{textcodes}  = ($hash{textcodes} eq '0')?$hash{textcodes}:'1';
    my $req;
    $req=POST(
        "https://api.neverbounce.com/v3/download?access_token=".$self->{access_token},
        Content_Type => 'form-data',
        Content      =>[
            job_id      =>  $self->{job_id},
            valids      =>  $self->{valids},
            invalids    =>  $self->{invalids},
            catchall    =>  $self->{catchall},
            disposable  =>  $self->{disposable},
            unknown     =>  $self->{unknown},
            duplicates  =>  $self->{duplicates},
            textcodes   =>  $self->{textcodes},
        ]
    );
    my $ua=LWP::UserAgent->new();
    $ua->ssl_opts( "verify_hostname" => 0 );
    $ua->agent('Mozilla/5.0');
    my $result=$ua->request($req);
    $result->{_content}=~s/\n+$//;
    $result->{_content}=~s/\r+$//;
    $result->{_content}=~s/\n+$//;
    if($result->is_success && $result->{_content} ne '') {
        my $temp=0;
        eval {decode_json($result->{_content});$temp=1;1;} or do {$temp=0;};
        if($temp > 0) {
            my $response=decode_json($result->{_content});
            if(defined($response->{error}) || (defined($response->{success}) && $response->{success} ne 1)) {
                my %response_hash = %{$response};
                my %error_data = $self->nb_error(%response_hash);
                $error_data{request_data} = Dumper($result);
                return %error_data;
            } else {
                return (resp_status=>'error',data => {error => 'Unknown Error',error_description => "Unknown Error"},request_data => Dumper($result));
            }
        } else {
            my %response_data = (
                resp_status     =>  'success',
                data            =>  {
                    list    =>  $result->{_content}
                },
                request_data    => Dumper($result)
            );
            return %response_data;
        }
    } else {
        my $msg=qq{Processing terminated due to failure in request to neverbounce.com};
        if($result->is_success && $result->{_content} eq '') {
            $msg=qq{Process terminated since there is no respone data from neverbounce.com};
        }
        return (resp_status=>'error',data => {error => 'Connection Error',error_description => $msg},request_data => Dumper($result));
    }
}
sub nb_result_code {
    my $self = shift;
    my %hash = @_;
    my %result_codes = (
        0           =>  {
            text_code   =>  'valid',
            numeric_code=>  '0',
            description =>  'Verified as real address',
            safe_to_send=>  'Yes'
        },
        1           =>  {
            text_code   =>  'invalid',
            numeric_code=>  '1',
            description =>  'Verified as not valid',
            safe_to_send=>  'No'
        },
        2           =>  {
            text_code   =>  'disposable',
            numeric_code=>  '2',
            description =>  'A temporary, disposable address',
            safe_to_send=>  'No'
        },
        3           =>  {
            text_code   =>  'catchall',
            numeric_code=>  '3',
            description =>  'A domain-wide setting',
            safe_to_send=>  'Maybe. Not recommended unless on private server'
        },
        4           =>  {
            text_code   =>  'unknown',
            numeric_code=>  '4',
            description =>  'The server cannot be reached',
            safe_to_send=>  'No'
        },
        'valid'     =>  {
            text_code   =>  'valid',
            numeric_code=>  '0',
            description =>  'Verified as real address',
            safe_to_send=>  'Yes'
        },
        'invalid'   =>  {
            text_code   =>  'invalid',
            numeric_code=>  '1',
            description =>  'Verified as not valid',
            safe_to_send=>  'No'
        },
        'disposable'=>  {
            text_code   =>  'disposable',
            numeric_code=>  '2',
            description =>  'A temporary, disposable address',
            safe_to_send=>  'No'
        },
        'catchall'  =>  {
            text_code   =>  'catchall',
            numeric_code=>  '3',
            description =>  'A domain-wide setting',
            safe_to_send=>  'Maybe. Not recommended unless on private server'
        },
        'unknown'   =>  {
            text_code   =>  'unknown',
            numeric_code=>  '4',
            description =>  'The server cannot be reached',
            safe_to_send=>  'No'
        }
    );
    if($hash{result_code} && $hash{result_code} ne '' && (($hash{result_code}=~/^\d+$/ && $hash{result_code} < 5) || $hash{result_code} eq 'valid' || $hash{result_code} eq 'invalid' || $hash{result_code} eq 'disposable' || $hash{result_code} eq 'catchall' || $hash{result_code} eq 'unknown')) {
        if($hash{response_type} && $hash{response_type} ne '') {
            if(defined($result_codes{$hash{result_code}}{$hash{response_type}})) {
                return $result_codes{$hash{result_code}}{$hash{response_type}};
            } else {
                return %{$result_codes{$hash{result_code}}};
            }
        } else {
            return %{$result_codes{$hash{result_code}}};
        }
    } else {
        return %result_codes;
    }
}
sub nb_error {
    my $self = shift;
    my %hash = @_;
    if(defined($hash{'error'})) {
        return (resp_status=>'error',data => {error => $hash{'error'},error_description => $hash{'error_description'}});
    } elsif(defined($hash{success}) && $hash{success} ne 'true') {
        if(defined($hash{msg}) && $hash{msg} ne '') {
            if($hash{'msg'} eq "Authentication failed") {
                return (resp_status=>'error',data => {error => 'Expired/Invalid Access Tokens',error_description => $hash{'msg'}});
            } else {
                return (resp_status=>'error',data => {error => 'API Errors',error_description => $hash{'msg'}});
            }
        } else {
            return (resp_status=>'error',data => {error => 'Error Code: '.$hash{'error_code'},error_description => $hash{'error_msg'}});
        }
    }
}
sub AUTOLOAD {
    my $self = shift;
	my $type = ref($self) || croak("$self is not an object");
	my $field = $AUTOLOAD;
	$field =~ s/.*://;
	my $temp='';
	unless (exists $self->{$field}) {
		die "$field does not exist in object/class $type";
	}
	exit(1);
}
sub DESTROY {
    my $self = undef;
}
1;
__END__