File Coverage

blib/lib/Business/OnlinePayment/PlugnPay.pm

Criterion	Covered	Total	%
statement	29	126	23.0
branch	3	40	7.5
condition	1	33	3.0
subroutine	6	11	54.5
pod	5	5	100.0
total	44	215	20.4

package Business::OnlinePayment::PlugnPay;

use strict;
use vars qw($VERSION $DEBUG);
use Carp qw(carp croak);

use base qw(Business::OnlinePayment::HTTPS);

$VERSION = '0.03';
$VERSION = eval $VERSION;
$DEBUG   = 0;

sub debug {
    my $self = shift;

    if (@_) {
        my $level = shift || 0;
        if ( ref($self) ) {
            $self->{"__DEBUG"} = $level;
        }
        else {
            $DEBUG = $level;
        }
        $Business::OnlinePayment::HTTPS::DEBUG = $level;
    }
    return ref($self) ? ( $self->{"__DEBUG"} || $DEBUG ) : $DEBUG;
}

sub set_defaults {
    my $self = shift;
    my %opts = @_;

    # standard B::OP methods/data
    $self->server("pay1.plugnpay.com");
    $self->port("443");
    $self->path("/payment/pnpremote.cgi");

    $self->build_subs(qw(
                          order_number avs_code cvv2_response
                          response_page response_code response_headers
                     ));

    # module specific data
    if ( $opts{debug} ) {
        $self->debug( $opts{debug} );
        delete $opts{debug};
    }

    my %_defaults = ();
    foreach my $key (keys %opts) {
      $key =~ /^default_(\w*)$/ or next;
      $_defaults{$1} = $opts{$key};
      delete $opts{$key};
    }
    $self->{_defaults} = \%_defaults;

}

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

    my %content = $self->content();

    #ACTION MAP
    my %actions = (
        'normal authorization' => 'auth',     # Authorization/Settle transaction
        'credit'               => 'newreturn',# Credit (refund)
        'void'                 => 'void',     # Void
    );

    $content{'mode'} = $actions{ lc( $content{'action'} ) }
      || $content{'action'};

    # TYPE MAP
    my %types = (
        'visa'             => 'CC',
        'mastercard'       => 'CC',
        'american express' => 'CC',
        'discover'         => 'CC',
        'cc'               => 'CC',
        'check'            => 'ECHECK',
    );

    $content{'type'} = $types{ lc( $content{'type'} ) } || $content{'type'};

    # PAYMETHOD MAP
    my %paymethods = (
        'CC'           => 'credit',
        'ECHECK'       => 'onlinecheck',
    );

    $content{'paymethod'} = $paymethods{ $content{'type'} };

    $self->transaction_type( $content{'type'} );

    $content{'transflags'} = 'recurring'
      if lc( $content{'recurring_billing'} ) eq 'yes';

    # stuff it back into %content
    $self->content(%content);
}

sub _revmap_fields {
    my ( $self, %map ) = @_;
    my %content = $self->content();
    foreach ( keys %map ) {
        $content{$_} =
          ref( $map{$_} )
          ? ${ $map{$_} }
          : $content{ $map{$_} };
    }
    $self->content(%content);
}

sub expdate_mmyy {
    my $self       = shift;
    my $expiration = shift;
    my $expdate_mmyy;
    if ( defined($expiration) and $expiration =~ /^(\d+)\D+\d*(\d{2})$/ ) {
        my ( $month, $year ) = ( $1, $2 );
        $expdate_mmyy = sprintf( "%02d/", $month ) . $year;
    }
    return defined($expdate_mmyy) ? $expdate_mmyy : $expiration;
}

sub required_fields {
    my($self,@fields) = @_;

    my @missing;
    my %content = $self->content();
    foreach(@fields) {
      next
        if (exists $content{$_} && defined $content{$_} && $content{$_}=~/\S+/);
      push(@missing, $_);
    }

    Carp::croak("missing required field(s): " . join(", ", @missing) . "\n")
      if(@missing);

}

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

    die "Processor does not support a test mode"
      if $self->test_transaction;

    $self->_map_fields();

    my %content = $self->content;

    my %required;
    $required{CC_auth} =  [ qw( mode publisher-name card-amount card-name
                                card-number card-exp paymethod ) ];
    $required{CC_newreturn} = [ @{$required{CC_auth}}, qw( publisher-password ) ];
    $required{CC_void} =  [ qw( mode publisher-name publisher-password orderID
                                card-amount ) ];
    #$required{ECHECK_auth} =  [ qw( mode publisher-name accttype routingnum
    #                                accountnum checknum paymethod ) ];
    my %optional;
    $optional{CC_auth} =  [ qw( publisher-email authtype required dontsndmail
                                easycard client convert cc-mail transflags
                                card-address1 card-address2 card-city card-state
                                card-prov card-zip card-country card-cvv
                                currency phone fax email shipinfo shipname
                                address1 address2 city state province zip
                                country ipaddress accttype orderID tax
                                shipping app-level order-id acct_code magstripe
                                marketdata carissuenum cardstartdate descrcodes
                                retailterms transflags ) ];
    $optional{CC_newreturn} = [ qw( orderID card-address1 card-address2
                                    card-city card-state card-zip card-country
                                    notify-email
                                  ) ];
    $optional{CC_void}      = [ qw( notify-email ) ];

    #$optional{ECHECK_auth}      = $optional{CC_auth};      # ?
    #$optional{ECHECK_newreturn} = $optional{CC_newreturn}; # ?  legal combo?
    #$optional{ECHECK_void}      = $optional{CC_void};      # ?  legal combo?

    my $type_action = $self->transaction_type(). '_'. $content{mode};
    unless ( exists($required{$type_action}) ) {
      $self->error_message("plugnpay can't handle transaction type: ".
        "$content{action} on " . $self->transaction_type() );
      $self->is_success(0);
      return;
    }

    my $expdate_mmyy = $self->expdate_mmyy( $content{"expiration"} );

    $self->_revmap_fields(

        'publisher-name'     => 'login',
        'publisher-password' => 'password',

        'card-amount'        => 'amount',
        'card-name'          => 'name',
        'card-address1'      => 'address',
        'card-city'          => 'city',
        'card-state'         => 'state',
        'card-zip'           => 'zip',
        'card-country'       => 'country',
        'card-number'        => 'card_number',
        'card-exp'           => \$expdate_mmyy,    # MMYY from 'expiration'
        'card-cvv'           => 'cvv2',
        'order-id'           => 'invoice_number',
        'orderID'            => 'order_number',


    );

    my %shipping_params = ( shipname => (($content{ship_first_name} || '') .
                                        ' '. ($content{ship_last_name} || '')),
                            address1 => $content{ship_address},
                            map { $_ => $content{ "ship_$_" } }
                              qw ( city state zip country )
                          );


    foreach ( keys ( %shipping_params ) ) {
      if ($shipping_params{$_} && $shipping_params{$_} =~ /^\s*$/) {
        delete $shipping_params{$_};
      }
    }
    $shipping_params{shipinfo} = 1 if scalar(keys(%shipping_params));

    my %params = ( $self->get_fields( @{$required{$type_action}},
                                      @{$optional{$type_action}},
                                    ),
                   (%shipping_params)
                 );

    $params{'txn-type'} = 'auth' if $params{mode} eq 'void';

    foreach ( keys ( %{($self->{_defaults})} ) ) {
      $params{$_} = $self->{_defaults}->{$_} unless exists($params{$_});
    }


    $self->required_fields(@{$required{$type_action}});

    warn join("\n", map{ "$_ => $params{$_}" } keys(%params)) if $DEBUG > 1;
    my ( $page, $resp, %resp_headers ) =
      $self->https_post( %params );

    $self->response_code( $resp );
    $self->response_page( $page );
    $self->response_headers( \%resp_headers );

    warn "$page\n" if $DEBUG > 1;
    # $page should contain key/value pairs

    my $status ='';
    my %results = map { s/\s*$//;
                        my ($name, $value) = split '=', $_, 2;
                        $name  =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg;
                        $value =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg;
                        $name, $value;
                      } split '&', $page;

    # AVS and CVS values may be set on success or failure
    $self->avs_code( $results{ 'avs-code' } );
    $self->cvv2_response( $results{ cvvresp } );
    $self->result_code( $results{ 'resp-code' } );
    $self->order_number( $results{ orderID } );
    $self->authorization( $results{ 'auth-code' } );
    $self->error_message( $results{ MErrMsg } );


    if ( $resp =~ /^(HTTP\S+ )?200/
      &&($results{ FinalStatus } eq "success" ||
         $results{ FinalStatus } eq "pending" && $results{ mode } eq 'newreturn'
        )
       ) {
        $self->is_success(1);
    } else {
        $self->is_success(0);
    }
}

1;

__END__