X-Git-Url: http://git.freeside.biz/gitweb/?a=blobdiff_plain;ds=sidebyside;f=FS%2FFS%2Fcust_main%2FBilling_Realtime.pm;h=d57be11abcafa644afbe9f2e502c6028f2de3bec;hb=e41cafbe7616c4f046c6161999d4577f1c918311;hp=ff1622cb434e0428a246b2b9036a40d031ad650a;hpb=da820d8c8837dce295e7cbd61accc22c4c019e14;p=freeside.git

diff --git a/FS/FS/cust_main/Billing_Realtime.pm b/FS/FS/cust_main/Billing_Realtime.pm
index ff1622cb4..d57be11ab 100644
--- a/FS/FS/cust_main/Billing_Realtime.pm
+++ b/FS/FS/cust_main/Billing_Realtime.pm
@@ -248,8 +248,9 @@ sub _bop_auth {
   );
 }
 
+### not a method!
 sub _bop_options {
-  my ($self, $options) = @_;
+  my ($options) = @_;
 
   $options->{payment_gateway}->gatewaynum
     ? $options->{payment_gateway}->options
@@ -413,15 +414,17 @@ sub realtime_bop {
 
   # possibly run a separate transaction to tokenize card number,
   #   so that we never store tokenized card info in cust_pay_pending
-  if (!$self->tokenized($options{'payinfo'})) {
+  if (($options{method} eq 'CC') && !$self->tokenized($options{'payinfo'})) {
     my $token_error = $self->realtime_tokenize(\%options);
     return $token_error if $token_error;
     # in theory, all cust_payby will be tokenized during original save,
     # so we shouldn't get here with opt cust_payby...but just in case...
-    if ($options{'cust_payby'}) {
+    if ($options{'cust_payby'} && $self->tokenized($options{'payinfo'})) {
       $token_error = $options{'cust_payby'}->replace;
       return $token_error if $token_error;
     }
+    return "Cannot tokenize card info"
+      if $conf->exists('no_saved_cardnumbers') && !$self->tokenized($options{'payinfo'});
   }
 
   ### 
@@ -690,7 +693,7 @@ sub realtime_bop {
     split( /\s*\,\s*/, $payment_gateway->gateway_action );
 
   my $transaction = new $namespace( $payment_gateway->gateway_module,
-                                    $self->_bop_options(\%options),
+                                    _bop_options(\%options),
                                   );
 
   $transaction->content(
@@ -750,7 +753,7 @@ sub realtime_bop {
 
     my $capture =
       new Business::OnlinePayment( $payment_gateway->gateway_module,
-                                   $self->_bop_options(\%options),
+                                   _bop_options(\%options),
                                  );
 
     my %capture = (
@@ -1281,7 +1284,7 @@ sub realtime_botpp_capture {
 
   my $transaction =
     new Business::OnlineThirdPartyPayment( $payment_gateway->gateway_module,
-                                           $self->_bop_options(\%options),
+                                           _bop_options(\%options),
                                          );
 
   $transaction->reference({ %options }); 
@@ -1765,11 +1768,13 @@ sub realtime_verify_bop {
 
   # possibly run a separate transaction to tokenize card number,
   #   so that we never store tokenized card info in cust_pay_pending
-  if (!$self->tokenized($options{'payinfo'})) {
+  if (($options{method} eq 'CC') && !$self->tokenized($options{'payinfo'})) {
     my $token_error = $self->realtime_tokenize(\%options);
     return $token_error if $token_error;
     #important that we not replace cust_payby here,
     #because cust_payby->replace uses realtime_verify_bop!
+    return "Cannot tokenize card info"
+      if $conf->exists('no_saved_cardnumbers') && !$self->tokenized($options{'payinfo'});
   }
 
   ###
@@ -1901,7 +1906,7 @@ sub realtime_verify_bop {
     warn Dumper($cust_pay_pending) if $DEBUG > 2;
 
     $transaction = new $namespace( $payment_gateway->gateway_module,
-                                   $self->_bop_options(\%options),
+                                   _bop_options(\%options),
                                     );
 
     $transaction->content(
@@ -1949,7 +1954,7 @@ sub realtime_verify_bop {
                      : '';
 
       my $reverse = new $namespace( $payment_gateway->gateway_module,
-                                    $self->_bop_options(\%options),
+                                    _bop_options(\%options),
                                   );
 
       $reverse->content( 'action'        => 'Reverse Authorization',
@@ -2213,9 +2218,11 @@ sub realtime_tokenize {
   ###
 
   my $transaction = new $namespace( $payment_gateway->gateway_module,
-                                    $self->_bop_options(\%options),
+                                    _bop_options(\%options),
                                   );
 
+  return '' unless $transaction->can('info');
+
   my %supported_actions = $transaction->info('supported_actions');
   return '' unless $supported_actions{'CC'}
                 && grep /^Tokenize$/, @{$supported_actions{'CC'}};
@@ -2318,12 +2325,227 @@ sub tokenized {
   FS::cust_pay->tokenized($payinfo);
 }
 
+=item token_check
+
+NOT A METHOD.  Acts on all customers.  Placed here because it makes
+use of module-internal methods, and to keep everything that uses
+Billing::OnlinePayment all in one place.
+
+Tokenizes all tokenizable card numbers from payinfo in cust_payby and 
+CARD transactions in cust_pay_pending, cust_pay, cust_pay_void and cust_refund.
+
+If all configured gateways have the ability to tokenize, then detection of
+an untokenizable record will cause a fatal error.
+
+=cut
+
+sub token_check {
+  # no input, acts on all customers
+
+  eval "use FS::Cursor";  
+  return "Error initializing FS::Cursor: ".$@ if $@;
+
+  my $dbh = dbh;
+
+  # get list of all gateways in table (not counting default gateway)
+  my $cache = {}; #cache for module info
+  my $sth = $dbh->prepare('SELECT DISTINCT gatewaynum FROM payment_gateway')
+    or die $dbh->errstr;
+  $sth->execute or die $sth->errstr;
+  my @gatewaynums;
+  while (my $row = $sth->fetchrow_hashref) {
+    push(@gatewaynums,$row->{'gatewaynum'});
+  }
+  $sth->finish;
+
+  # look for a gateway that can't tokenize
+  my $disallow_untokenized = 1;
+  foreach my $gatewaynum ('',@gatewaynums) {
+    my $gateway = FS::agent->payment_gateway( load_gatewaynum => $gatewaynum, nofatal => 1 );
+    if (!$gateway) { # already died if $gatewaynum
+      # no default gateway, no promise to tokenize
+      # can just load other gateways as-needeed below
+      $disallow_untokenized = 0;
+      last;
+    }
+    my $info = _token_check_gateway_info($cache,$gateway);
+    return $info unless ref($info); # means it's an error message
+    unless ($info->{'can_tokenize'}) {
+      # a configured gateway can't tokenize, that's all we need to know right now
+      # can just load other gateways as-needeed below
+      $disallow_untokenized = 0;
+      last;
+    }
+  }
+
+  my $oldAutoCommit = $FS::UID::AutoCommit;
+  local $FS::UID::AutoCommit = 0;
+
+  ### Tokenize cust_payby
+
+  my $cust_search = FS::Cursor->new({ table => 'cust_main' },$dbh);
+  while (my $cust_main = $cust_search->fetch) {
+    foreach my $cust_payby ($cust_main->cust_payby('CARD','DCRD')) {
+      next if $cust_payby->tokenized;
+      # load gateway first, just so we can cache it
+      my $payment_gateway = $cust_main->_payment_gateway({
+        'nofatal' => 1, # handle error smoothly below
+      });
+      unless ($payment_gateway) {
+        # no reason to have untokenized card numbers saved if no gateway,
+        #   but only fatal if we expected everyone to tokenize card numbers
+        next unless $disallow_untokenized;
+        $cust_search->DESTROY;
+        $dbh->rollback if $oldAutoCommit;
+        return "No gateway found for custnum ".$cust_main->custnum;
+      }
+      my $info = _token_check_gateway_info($cache,$payment_gateway);
+      # no fail here--a configured gateway can't tokenize, so be it
+      next unless ref($info) && $info->{'can_tokenize'};
+      my %tokenopts = (
+        'payment_gateway' => $payment_gateway,
+        'cust_payby'      => $cust_payby,
+      );
+      my $error = $cust_main->realtime_tokenize(\%tokenopts);
+      if ($cust_payby->tokenized) { # implies no error
+        $error = $cust_payby->replace;
+      } else {
+        $error ||= 'Unknown error';
+      }
+      if ($error) {
+        $cust_search->DESTROY;
+        $dbh->rollback if $oldAutoCommit;
+        return "Error tokenizing cust_payby ".$cust_payby->custpaybynum.": ".$error;
+      }
+    }
+  }
+
+  ### Tokenize/mask transaction tables
+
+  # grep assistance:
+  #   $cust_pay_pending->replace, $cust_pay->replace, $cust_pay_void->replace, $cust_refund->replace all run here
+  foreach my $table ( qw(cust_pay_pending cust_pay cust_pay_void cust_refund) ) {
+    my $search = FS::Cursor->new({
+      table     => $table,
+      hashref   => { 'payby' => 'CARD' },
+    },$dbh);
+    while (my $record = $search->fetch) {
+      next if $record->tokenized;
+      next if !$record->payinfo; #shouldn't happen, but at least it's not a card number
+      next if $record->payinfo =~ /N\/A/; # ??? Not sure why we do this, but it's not a card number
+
+      # don't use customer agent gateway here, use the gatewaynum specified by the record
+      my $gatewaynum = $record->gatewaynum || '';
+      my $gateway = FS::agent->payment_gateway( load_gatewaynum => $gatewaynum );
+      unless ($gateway) { # already died if $gatewaynum
+        # only fatal if we expected everyone to tokenize
+        next unless $disallow_untokenized;
+        $search->DESTROY;
+        $dbh->rollback if $oldAutoCommit;
+        return "No gateway found for $table ".$record->get($record->primary_key);
+      }
+      my $info = _token_check_gateway_info($cache,$gateway);
+      unless (ref($info)) {
+        # only throws error if Business::OnlinePayment won't load,
+        #   which is just cause to abort this whole process
+        $search->DESTROY;
+        $dbh->rollback if $oldAutoCommit;
+        return $info; # error message
+      }
+
+      # a configured gateway can't tokenize, move along
+      next unless $info->{'can_tokenize'};
+
+      my $cust_main = $record->cust_main;
+      unless ($cust_main) {
+        # might happen for cust_pay_pending for failed verify records,
+        #   in which case it *should* already be tokenized if possible
+        #   but only get strict about it if we're expecting full tokenization
+        next if 
+          $table eq 'cust_pay_pending'
+            && $record->{'custnum_pending'}
+            && !$disallow_untokenized;
+        # XXX we currently need a $cust_main to run realtime_tokenize
+        #     even if we made it a class method, wouldn't have access to payname/etc.
+        #     fail for now, but probably could handle this better...
+        # everything else should absolutely have a cust_main
+        $search->DESTROY;
+        $dbh->rollback if $oldAutoCommit;
+        return "Could not load cust_main for $table ".$record->get($record->primary_key);
+      }
+      my %tokenopts = (
+        'payment_gateway' => $gateway,
+        'method'          => 'CC',
+        'payinfo'         => $record->payinfo,
+        'paydate'         => $record->paydate,
+      );
+      my $error = $cust_main->realtime_tokenize(\%tokenopts);
+      if ($cust_main->tokenized($tokenopts{'payinfo'})) { # implies no error
+        $record->payinfo($tokenopts{'payinfo'});
+        $error = $record->replace;
+      } else {
+        $error = 'Unknown error';
+      }
+      if ($error) {
+        $search->DESTROY;
+        $dbh->rollback if $oldAutoCommit;
+        return "Error tokenizing $table ".$record->get($record->primary_key).": ".$error;
+      }
+    } # end record loop
+  } # end table loop
+
+  $dbh->commit if $oldAutoCommit;
+
+  return '';
+}
+
+# not a method!
+sub _token_check_gateway_info {
+  my ($cache,$payment_gateway) = @_;
+
+  return $cache->{$payment_gateway->gateway_module}
+    if $cache->{$payment_gateway->gateway_module};
+
+  my $info = {};
+  $cache->{$payment_gateway->gateway_module} = $info;
+
+  my $namespace = $payment_gateway->gateway_namespace;
+  return $info unless $namespace eq 'Business::OnlinePayment';
+  $info->{'is_bop'} = 1;
+
+  # only need to load this once,
+  # don't want to load if nothing is_bop
+  unless ($cache->{'Business::OnlinePayment'}) {
+    eval "use $namespace";  
+    return "Error initializing Business:OnlinePayment: ".$@ if $@;
+    $cache->{'Business::OnlinePayment'} = 1;
+  }
+
+  my $transaction = new $namespace( $payment_gateway->gateway_module,
+                                    _bop_options({ 'payment_gateway' => $payment_gateway }),
+                                  );
+
+  return $info unless $transaction->can('info');
+  $info->{'can_info'} = 1;
+
+  my %supported_actions = $transaction->info('supported_actions');
+  $info->{'can_tokenize'} = 1
+    if $supported_actions{'CC'}
+      && grep /^Tokenize$/, @{$supported_actions{'CC'}};
+
+  # not using this any more, but for future reference...
+  $info->{'void_requires_card'} = 1
+    if $transaction->info('CC_void_requires_card');
+
+  $cache->{$payment_gateway->gateway_module} = $info;
+
+  return $info;
+}
+
 =back
 
 =head1 BUGS
 
-Not autoloaded.
-
 =head1 SEE ALSO
 
 L<FS::cust_main>, L<FS::cust_main::Billing>