File Coverage

blib/lib/WebService/Antigate.pm

Criterion	Covered	Total	%
statement	57	68	83.8
branch	14	24	58.3
condition	19	43	44.1
subroutine	12	14	85.7
pod	7	7	100.0
total	109	156	69.8

package WebService::Antigate;

use strict;
use LWP::UserAgent ();
use Carp ();

our $VERSION = '0.10';

our $DOMAIN = 'anti-captcha.com'; # service domain often changes because of the abuse
our $WAIT   = 220;                # default time that recognize() or upload() can work
our $DELAY  = 5;                  # sleep time before retry while uploading or recognizing captcha
our $FNAME  = 'captcha.jpg';      # default name of the uploaded captcha if name not specified and can't be determined

my %API_VERSIONS = (
	1 => sub { require WebService::Antigate::V1; 'WebService::Antigate::V1' },
	2 => sub { require WebService::Antigate::V2; 'WebService::Antigate::V2' },
);

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

    Carp::croak "Option `key' should be specified" unless defined $args{key};

    my $self = {};
    $self->{key}         = $args{key};
    $self->{wait}        = $args{wait};
    $self->{attempts}    = $args{attempts};
    $self->{ua}          = $args{ua}     || LWP::UserAgent->new();
    $self->{domain}      = $args{domain} || $DOMAIN;
    $self->{delay}       = $args{delay}  || $DELAY;
	$self->{scheme}      = $args{scheme} || 'http';
	$self->{subdomain}   = $args{subdomain};
	$self->{api_version} = $args{api_version} || 1;

    $self->{wait} = $WAIT unless defined($self->{wait}) || defined($self->{attempts});

	Carp::croak "Unsupported `api_version' specified" unless exists $API_VERSIONS{ $self->{api_version} };
    bless $self, $class eq __PACKAGE__ ? $API_VERSIONS{ $self->{api_version} }->() : $class;
}

# generate sub's for get/set object properties using closure
foreach my $key (qw(key wait attempts ua scheme domain subdomain delay)) {
    no strict 'refs';
    *$key = sub {
        my $self = shift;

        return $self->{$key} = $_[0] if defined $_[0];
        return $self->{$key};
    }
}

sub errno {
    return $_[0]->{errno};
}

sub errstr {
    return $_[0]->{errstr};
}

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

    my $start = time();
    my $attempts = 0;
    my $captcha_id;

    do {
        $attempts ++;
        $captcha_id = $self->try_upload(%opts);
    }
    while ( !$captcha_id &&
          ($self->{errno} eq 'ERROR_NO_SLOT_AVAILABLE' || $self->{errno} eq 'HTTP_ERROR') &&
          (defined($self->{wait}) ? ( time() - $start ) < $self->{wait} : 1) &&
          $attempts != $self->{attempts} &&
          sleep( $self->{delay} )
        );

    return $captcha_id;
}

sub recognize {
    my ($self, $id) = @_;

    my $start = time();
    my $captcha_text;
    my $attempts = 0;

    do
    {
        $attempts ++;
        sleep( $self->{delay} );
        $captcha_text = $self->try_recognize($id);
    }
    while ( !$captcha_text &&
          ($self->{errno} eq 'CAPCHA_NOT_READY' || $self->{errno} eq 'HTTP_ERROR') &&
          (defined($self->{wait}) ? ( time() - $start ) < $self->{wait} : 1) &&
          $attempts != $self->{attempts}
        );

    return $captcha_text;
}

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

    my $captcha_id;
    unless($captcha_id = $self->upload(%opts))
    {
        return undef;
    }

    return $self->recognize($captcha_id);
}

sub last_captcha_id {
    my ($self) = @_;
    return $self->{last_captcha_id};
}

sub _name_by_signature {
    if ($_[1] =~ /^\x47\x49\x46\x38(?:\x37|\x39)\x61/)
    {
        return 'captcha.gif';
    }

    if ($_[1] =~ /^\x89\x50\x4E\x47\x0D\x0A\x1A\x0A/)
    {
        return 'captcha.png';
    }

    if ($_[1] =~ /^\xFF\xD8\xFF\xE0..\x4A\x46\x49\x46\x00/)
    {
        return 'captcha.jpg';
    }

    return $FNAME;
}

sub _name_by_file_signature {
    my $self = shift;

	open my $fh, '<:raw', $_[0] or return $self->_name_by_signature('');
    sysread($fh, my $buf, 20);
    close $fh;
    return $self->_name_by_signature($buf);
}

1;

__END__