# Vend::Payment::PSiGate - Interchange PSiGate support

#

# Copyright (C) 2002-2007 Interchange Development Group, https://www.interchangecommerce.org/

# Copyright (C) 1999-2002 Red Hat, Inc.

#

# Gary Benson <gary@geton.com>

# Mike Heins <mikeh@perusion.com>

# webmaster@nameastar.net

# Jeff Nappi <brage@cyberhighway.net>

# Paul Delys <paul@gi.alaska.edu>

# Mark Stosberg <mark@summersault.com>

#

# Edited by Ray Desjardins <ray@dfwmicrotech.com>

# Patches for AUTH_CAPTURE and VOID support contributed by

# nferrari@ccsc.com (Nelson H Ferrari)

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public

# License along with this program; if not, write to the Free

# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,

# MA 02110-1301 USA.

# Connection routine for PSiGate using the 'HTML Posting Direct Response'

# method.

# Reworked extensively to support new Interchange payment stuff by Mike Heins

package Vend::Payment::PSiGate;

=head1 NAME

Vend::Payment::PSiGate - Interchange PSiGate Support

=head1 SYNOPSIS

&charge=psigate

or

[charge mode=psigate param1=value1 param2=value2]

=head1 PREREQUISITES

Net::SSLeay

or

LWP::UserAgent and Crypt::SSLeay

Only one of these need be present and working.

=head1 DESCRIPTION

The Vend::Payment::PSiGate module implements the psigate() routine

for use with Interchange. It is compatible on a call level with the other

Interchange payment modules.

To enable this module, place this directive in C<interchange.cfg>:

Require module Vend::Payment::PSiGate

This I<must> be in interchange.cfg or a file included from it.

Make sure CreditCardAuto is off (default in Interchange demos).

The mode can be named anything, but the C<gateway> parameter must be set

to C<psigate>. To make it the default payment gateway for all credit

card transactions in a specific catalog, you can set in C<catalog.cfg>:

Variable MV_PAYMENT_MODE psigate

It uses several of the standard settings from Interchange payment. Any time

we speak of a setting, it is obtained either first from the tag/call

options,

then from an Interchange order Route named for the mode, then finally a

default global payment variable, For example, the C<id> parameter would

be specified by:

[charge mode=psigate id=YourPSiGateMerchantID]

or

Route psigate id YourPSiGateMerchantID

or

Variable MV_PAYMENT_ID YourPSiGateMerchantID

The active settings are:

=over 4

=item id

Your PSiGate.com account ID, supplied by PSiGate.com when you sign up.

Global parameter is MV_PAYMENT_ID.

=item referer

A valid referering url (match this with your setting on PSiGate).

Global parameter is MV_PAYMENT_REFERER.

=item transaction

The type of transaction to be run. Valid values are:

Interchange PSiGate Note

---------------- ----------------- ---------

auth '1', PreAuth

sale '0', Sale

settle '2', PostAuth

void '9', Void

=item remap

This remaps the form variable names to the ones needed by PSiGate. See

the C<Payment Settings> heading in the Interchange documentation for use.

=item test

Set this to C<TRUE> if you wish to operate in test mode, i.e. set the

PSiGate

C<x_Test_Request> query paramter to TRUE.i

Examples:

Route psigate test TRUE

or

Variable MV_PAYMENT_TEST TRUE

or

[charge mode=psigate test=TRUE]

=back

=head2 Troubleshooting

Try the instructions above, then enable test mode. A test order should

complete.

Disable test mode, then test in various PSiGate error modes by

using the credit card number 4111 1111 1111 1111.

Then try a sale with the card number C<4111 1111 1111 1111>

and a valid expiration date. The sale should be denied, and the reason

should

be in [data session payment_error].

If nothing works:

=over 4

=item *

Make sure you "Require"d the module in interchange.cfg:

Require module Vend::Payment::PSiGate

=item *

Make sure either Net::SSLeay or Crypt::SSLeay and LWP::UserAgent are

installed

and working. You can test to see whether your Perl thinks they are:

perl -MNet::SSLeay -e 'print "It works\n"'

or

perl -MLWP::UserAgent -MCrypt::SSLeay -e 'print "It works\n"'

If either one prints "It works." and returns to the prompt you should be OK

(presuming they are in working order otherwise).

=item *

Check the error logs, both catalog and global.

=item *

Make sure you set your payment parameters properly.

=item *

Try an order, then put this code in a page:

<XMP>

[calc]

my $string = $Tag->uneval( { ref => $Session->{payment_result} });

$string =~ s/{/{\n/;

$string =~ s/,/,\n/g;

return $string;

[/calc]

</XMP>

That should show what happened.

=item *

If all else fails, Red Hat and other consultants are available to help

with integration for a fee.

=back

=head1 BUGS

There is actually nothing *in* Vend::Payment::PSiGate. It changes packages

to Vend::Payment and places things there.

=head1 AUTHORS

Mark Stosberg <mark@summersault.com>, based on original code by Mike Heins

<mheins@redhat.com>.

=head1 CREDITS

Jeff Nappi <brage@cyberhighway.net>

Paul Delys <paul@gi.alaska.edu>

webmaster@nameastar.net

Ray Desjardins <ray@dfwmicrotech.com>

Nelson H. Ferrari <nferrari@ccsc.com>

=cut

BEGIN {

my $selected;

eval {

package Vend::Payment;

require Net::SSLeay;

import Net::SSLeay qw(post_https make_form make_headers);

$selected = "Net::SSLeay";

};

$Vend::Payment::Have_Net_SSLeay = 1 unless $@;

unless ($Vend::Payment::Have_Net_SSLeay) {

eval {

package Vend::Payment;

require LWP::UserAgent;

require HTTP::Request::Common;

require Crypt::SSLeay;

import HTTP::Request::Common qw(POST);

$selected = "LWP and Crypt::SSLeay";

};

$Vend::Payment::Have_LWP = 1 unless $@;

}

unless ($Vend::Payment::Have_Net_SSLeay or $Vend::Payment::Have_LWP) {

die __PACKAGE__ . " requires Net::SSLeay or Crypt::SSLeay";

}

::logGlobal("%s payment module initialized, using %s", __PACKAGE__, $selected)

unless $Vend::Quiet or ! $Global::VendRoot;

}

package Vend::Payment;

sub psigate {

my ($user, $amount) = @_;

my $opt;

if(ref $user) {

$opt = $user;

$user = $opt->{id} || undef;

# $secret = $opt->{secret} || undef;

}

else {

$opt = {};

}

my $actual;

if($opt->{actual}) {

$actual = $opt->{actual};

}

else {

my (%actual) = map_actual();

$actual = \%actual;

}

#::logDebug("actual map result: " . ::uneval($actual));

if (! $user ) {

$user = charge_param('id');

if (! $user ) {

return (

MStatus => 'failure-hard',

MErrMsg => errmsg('No account id'),

);

}

}

# $secret = charge_param('secret') if ! $secret;

$opt->{host} ||= 'order.psigate.com';

$opt->{script} ||= 'order.asp';

$opt->{port} ||= 443;

my $precision = $opt->{precision}

|| 2;

# my $referer = $opt->{referer}

# || charge_param('referer');

## PSiGate does things a bit different, ensure we are OK

$actual->{mv_credit_card_exp_month} =~ s/\D//g;

$actual->{mv_credit_card_exp_month} =~ s/^0+//;

$actual->{mv_credit_card_exp_year} =~ s/\D//g;

$actual->{mv_credit_card_exp_year} =~ s/\d\d(\d\d)/$1/;

$actual->{mv_credit_card_number} =~ s/\D//g;

# my $exp = sprintf '%02d%02d',

# $actual->{mv_credit_card_exp_month},

# $actual->{mv_credit_card_exp_year};

my $expmonth = sprintf '%02d',$actual->{mv_credit_card_exp_month};

my $expyear = sprintf '%02d',$actual->{mv_credit_card_exp_year};

my $bname = $actual->{b_fname}." ".$actual->{b_lname};

# Using mv_payment_mode for compatibility with older versions, probably not

# necessary.

$opt->{transaction} ||= 'sale';

my $transtype = $opt->{transaction};

my %type_map = (

auth => '1',

sale => '0',

settle => '2',

void => '9',

);

if (defined $type_map{$transtype}) {

$transtype = $type_map{$transtype};

} else {

return (

MStatus => 'failure-hard',

MErrMsg => errmsg('Invalid transaction type "%s"', $transtype),

);

}

$amount = $opt->{total_cost} if $opt->{total_cost};

if(! $amount) {

$amount = Vend::Interpolate::total_cost();

$amount = Vend::Util::round_to_frac_digits($amount,$precision);

}

$order_id = gen_order_id($opt);

my %query = (

CardNumber => $actual->{mv_credit_card_number},

MerchantID => $user,

Bname => $bname,

Baddr1 => $actual->{b_address},

Bcity => $actual->{b_city},

Bstate => $actual->{b_state},

Bzip => $actual->{b_zip},

Bcountry => $actual->{b_country},

FullTotal => $amount,

ExpMonth => $expmonth,

ExpYear => $expyear,

Oid => $actual->{order_id},

Bcompany => $actual->{company},

Email => $actual->{email},

Phone => $actual->{phone_day},

IP => $CGI::remote_addr,

);

my @query;

for (keys %query) {

my $key = $_;

my $val = $query{$key};

$val =~ s/["\$\n\r]//g;

$val =~ s/\$//g;

my $len = length($val);

if($val =~ /[&=]/) {

$key .= "[$len]";

}

push @query, "$key=$val";

}

my $string = join '&', @query;

#::logDebug("PSiGate query: " . ::uneval(\%query));

$opt->{extra_headers} = { Referer => $referer };

my $thing = post_data($opt, \%query);

my $page = $thing->{result_page};

my $response = $thing->{status_line};

# Minivend names are on the left, PSiGate on the right

my %result_map = ( qw/

pop.status PSi_Response_AppCod

pop.error-message PSi_Response_ErrMsg

order-id PSi_Response_Oid

pop.order-id PSi_Response_Oid

pop.auth-code PSi_Response_Code

pop.avs_code PSi_Response_Addnum

pop.avs_zip PSi_Response_Bzip

pop.avs_addr PSi_Response_Baddr1

/

);

#::logDebug(qq{\npsigate page: $page response: $response\n});

my %result;

@result{

qw/

PSi_Response_AppCode

PSi_Response_ErrMsg

PSi_Response_Code

PSi_Response_TransTime

PSi_Response_RefNo

PSi_Response_OrdNo

PSi_Response_SubTotal

PSi_Response_ShipTotal

PSi_Response_TaxTotal

PSi_Response_Total

PSi_Response_MerchantID

PSi_Response_Oid

PSi_Response_Userid

PSi_Response_Bname

PSi_Response_Bcompany

PSi_Response_Baddr1

PSi_Response_Baddr2

PSi_Response_Bcity

PSi_Response_Bstate

PSi_Response_Bzip

PSi_Response_Bcountry

PSi_Response_Sname

PSi_Response_Saddr1

PSi_Response_Saddr2

PSi_Response_Scity

PSi_Response_Sstate

PSi_Response_Szip

PSi_Response_Scountry

PSi_Response_Phone

PSi_Response_Fax

PSi_Response_ShipType

PSi_Response_Comments

PSi_Response_Email

PSi_Response_ReferNum

PSi_Response_ChargeType

PSi_Response_Result

PSi_Response_Addnum

PSi_Response_IP

PSi_Response_Country

PSi_Response_State

PSi_Response_Items

PSi_Response_Weight

PSi_Response_Carrier

PSi_Response_ShipOn

PSi_Response_TaxState

PSi_Response_TaxZip

PSi_Response_TaxOn

PSi_Response_FullTotal

/

}

= split (/,/,$page);

#::logDebug(qq{psigate PSi_Response_ErrMsg=$result{PSi_Response_ErrMsg} response_code: $result{PSi_Response_AppCode}});

for (keys %result_map) {

$result{$_} = $result{$result_map{$_}}

if defined $result{$result_map{$_}};

}

if ($result{PSi_Response_AppCode} == 1) {

$result{MStatus} = 'success';

$result{'order-id'} ||= $opt->{order_id};

}

else {

$result{MStatus} = 'failure';

delete $result{'order-id'};

$result{MErrMsg} = errmsg($result{PSi_Response_ErrMsg});

MErrMsg => errmsg('No account id'),

}

return (%result);

}

package Vend::Payment::PSiGate;

1;