X-Git-Url: http://git.freeside.biz/gitweb/?p=freeside.git;a=blobdiff_plain;f=FS%2FFS%2Fcust_pay.pm;h=f3c0b197fca5f22469bf3e8d3c97f7f2d80537ba;hp=0e9e8a716bf00c1a26e01874110a1d321fc0e497;hb=cad17f4aca6b4c673cb72ac7af69d9a83f406e91;hpb=54a357b171aa44f9399b4c146acd2afd3b686075 diff --git a/FS/FS/cust_pay.pm b/FS/FS/cust_pay.pm index 0e9e8a716..f3c0b197f 100644 --- a/FS/FS/cust_pay.pm +++ b/FS/FS/cust_pay.pm @@ -4,13 +4,14 @@ use strict; use base qw( FS::otaker_Mixin FS::payinfo_transaction_Mixin FS::cust_main_Mixin FS::Record ); use vars qw( $DEBUG $me $conf @encrypted_fields - $unsuspendauto $ignore_noapply + $ignore_noapply ); use Date::Format; use Business::CreditCard; use Text::Template; -use FS::UID qw( getotaker ); +use FS::UID qw( getotaker driver_name ); use FS::Misc qw( send_email ); +use FS::Misc::DateTime qw( parse_datetime ); #for batch_import use FS::Record qw( dbh qsearch qsearchs ); use FS::CurrentUser; use FS::payby; @@ -23,6 +24,7 @@ use FS::cust_main; use FS::cust_pkg; use FS::cust_pay_void; use FS::upgrade_journal; +use FS::Cursor; $DEBUG = 0; @@ -33,10 +35,10 @@ $ignore_noapply = 0; #ask FS::UID to run this stuff for us later FS::UID->install_callback( sub { $conf = new FS::Conf; - $unsuspendauto = $conf->exists('unsuspendauto'); } ); @encrypted_fields = ('payinfo'); +sub nohistory_fields { ('payinfo'); } =head1 NAME @@ -94,6 +96,10 @@ Payment Type (See L for valid values) Payment Information (See L for data format) +=item paycardtype + +Credit card type, if appropriate; autodetected. + =item paymask Masked payinfo (See L for how this works) @@ -114,6 +120,10 @@ books closed flag, empty or `Y' Desired pkgnum when using experimental package balances. +=item no_auto_apply + +Flag to only allow manual application of payment, empty or 'Y' + =item bank The bank where the payment was deposited. @@ -192,6 +202,15 @@ A hash of optional arguments may be passed. Currently "manual" is supported. If true, a payment receipt is sent instead of a statement when 'payment_receipt_email' configuration option is set. +About the "manual" flag: Normally, if the 'payment_receipt' config option +is set, and the customer has an invoice email address, inserting a payment +causes a I to be emailed to the customer. If the payment is +considered "manual" (or if the customer has no invoices), then it will +instead send a I. "manual" should be true whenever a +payment is created directly from the web interface, from a user-initiated +realtime payment, or from a third-party payment via self-service. It should +be I when creating a payment from a billing event or from a batch. + =cut sub insert { @@ -215,6 +234,12 @@ sub insert { $dbh->rollback if $oldAutoCommit; return "Unknown cust_bill.invnum: ". $self->invnum; }; + if ($self->custnum && ($cust_bill->custnum ne $self->custnum)) { + $dbh->rollback if $oldAutoCommit; + return "Invoice custnum ".$cust_bill->custnum + ." does not match specified custnum ".$self->custnum + ." for invoice ".$self->invnum; + } $self->custnum($cust_bill->custnum ); } @@ -319,16 +344,8 @@ sub insert { $dbh->commit or die $dbh->errstr if $oldAutoCommit; - #false laziness w/ cust_credit::insert - if ( $unsuspendauto && $old_balance && $cust_main->balance <= 0 ) { - my @errors = $cust_main->unsuspend; - #return - # side-fx with nested transactions? upstack rolls back? - warn "WARNING:Errors unsuspending customer ". $cust_main->custnum. ": ". - join(' / ', @errors) - if @errors; - } - #eslaf + # possibly trigger package unsuspend, doesn't abort transaction on failure + $self->unsuspend_balance if $old_balance; #bill setup fees for voip_cdr bill_every_call packages #some false laziness w/search in freeside-cdrd @@ -374,6 +391,22 @@ sub insert { warn "can't send payment receipt/statement: $error" if $error; } + #run payment events immediately + my $due_cust_event = $self->cust_main->due_cust_event( + 'eventtable' => 'cust_pay', + 'objects' => [ $self ], + ); + if ( !ref($due_cust_event) ) { + warn "Error searching for cust_pay billing events: $due_cust_event\n"; + } else { + foreach my $cust_event (@$due_cust_event) { + next unless $cust_event->test_conditions; + if ( my $error = $cust_event->do_event() ) { + warn "Error running cust_pay billing event: $error\n"; + } + } + } + ''; } @@ -404,12 +437,17 @@ sub void { } ); $cust_pay_void->reason(shift) if scalar(@_); my $error = $cust_pay_void->insert; - if ( $error ) { - $dbh->rollback if $oldAutoCommit; - return $error; + + my $cust_pay_pending = + qsearchs('cust_pay_pending', { paynum => $self->paynum }); + if ( $cust_pay_pending ) { + $cust_pay_pending->set('void_paynum', $self->paynum); + $cust_pay_pending->set('paynum', ''); + $error ||= $cust_pay_pending->replace; } - $error = $self->delete; + $error ||= $self->delete; + if ( $error ) { $dbh->rollback if $oldAutoCommit; return $error; @@ -510,7 +548,8 @@ otherwise returns false. sub replace { my $self = shift; - return "Can't modify closed payment" if $self->closed =~ /^Y/i; + return "Can't modify closed payment" + if $self->closed =~ /^Y/i && !$FS::payinfo_Mixin::allow_closed_replace; $self->SUPER::replace(@_); } @@ -535,6 +574,7 @@ sub check { || $self->ut_textn('paybatch') || $self->ut_textn('payunique') || $self->ut_enum('closed', [ '', 'Y' ]) + || $self->ut_flag('no_auto_apply') || $self->ut_foreign_keyn('pkgnum', 'cust_pkg', 'pkgnum') || $self->ut_textn('bank') || $self->ut_alphan('depositor') @@ -626,11 +666,23 @@ sub send_receipt { { my $msgnum = $conf->config('payment_receipt_msgnum', $cust_main->agentnum); if ( $msgnum ) { - my $msg_template = FS::msg_template->by_key($msgnum); - $error = $msg_template->send( - 'cust_main' => $cust_main, - 'object' => $self, - 'from_config' => 'payment_receipt_from', + + my %substitutions = (); + $substitutions{invnum} = $opt->{cust_bill}->invnum if $opt->{cust_bill}; + + my $queue = new FS::queue { + 'job' => 'FS::Misc::process_send_email', + 'paynum' => $self->paynum, + 'custnum' => $cust_main->custnum, + }; + $error = $queue->insert( + FS::msg_template->by_key($msgnum)->prepare( + 'cust_main' => $cust_main, + 'object' => $self, + 'from_config' => 'payment_receipt_from', + 'substitutions' => \%substitutions, + ), + 'msgtype' => 'receipt', # override msg_template's default ); } elsif ( $conf->exists('payment_receipt_email') ) { @@ -664,13 +716,21 @@ sub send_receipt { 'company_name' => $conf->config('company_name', $cust_main->agentnum), ); + $fill_in{'invnum'} = $opt->{cust_bill}->invnum if $opt->{cust_bill}; + if ( $opt->{'cust_pkg'} ) { $fill_in{'pkg'} = $opt->{'cust_pkg'}->part_pkg->pkg; #setup date, other things? } - $error = send_email( - 'from' => $conf->config('invoice_from', $cust_main->agentnum), + my $queue = new FS::queue { + 'job' => 'FS::Misc::process_send_generated_email', + 'paynum' => $self->paynum, + 'custnum' => $cust_main->custnum, + 'msgtype' => 'receipt', + }; + $error = $queue->insert( + 'from' => $conf->invoice_from_full( $cust_main->agentnum ), #invoice_from??? well as good as any 'to' => \@invoicing_list, 'subject' => 'Payment receipt', @@ -685,21 +745,69 @@ sub send_receipt { } elsif ( ! $cust_main->invoice_noemail ) { #not manual - my $queue = new FS::queue { - 'paynum' => $self->paynum, - 'job' => 'FS::cust_bill::queueable_email', - }; + # check to see if they want to send specific message template as receipt for auto payments + my $msgnum = $conf->config('payment_receipt_msgnum_auto', $cust_main->agentnum); + if ( $msgnum ) { + + my %substitutions = (); + $substitutions{invnum} = $opt->{cust_bill}->invnum if $opt->{cust_bill}; + + my $msg_template = qsearchs('msg_template',{ msgnum => $msgnum}); + unless ($msg_template) { + warn "send_receipt could not load msg_template"; + return; + } + + my $cust_msg = $msg_template->prepare( + 'cust_main' => $cust_main, + 'object' => $self, + 'from_config' => 'payment_receipt_from', + 'substitutions' => \%substitutions, + 'msgtype' => 'receipt', + ); + $error = $cust_msg ? $cust_msg->insert : 'error preparing msg_template'; + if ($error) { + warn "send_receipt: $error"; + return; + } + + my $queue = new FS::queue { + 'job' => 'FS::cust_msg::process_send', + 'paynum' => $self->paynum, + 'custnum' => $cust_main->custnum, + }; + $error = $queue->insert( $cust_msg->custmsgnum ); + + } + else { + my $queue = new FS::queue { + 'job' => 'FS::cust_bill::queueable_email', + 'paynum' => $self->paynum, + 'custnum' => $cust_main->custnum, + }; + + my %opt = ( + 'invnum' => $cust_bill->invnum, + 'no_coupon' => 1, + ); + + if ( my $mode = $conf->config('payment_receipt_statement_mode') ) { + $opt{'mode'} = $mode; + } else { + # backward compatibility, no good fix for this yet as some people may + # still have "invoice_latex_statement" and such options + $opt{'template'} = 'statement'; + $opt{'notice_name'} = 'Statement'; + } + + $error = $queue->insert(%opt); + } + - $error = $queue->insert( - 'invnum' => $cust_bill->invnum, - 'template' => 'statement', - 'notice_name' => 'Statement', - 'no_coupon' => 1, - ); } - warn "send_receipt: $error\n" if $error; + warn "send_receipt: $error\n" if $error; } =item cust_bill_pay @@ -775,6 +883,154 @@ sub amount { $self->paid(); } +=item delete_cust_bill_pay OPTIONS + +Deletes all associated cust_bill_pay records. + +If option 'unapplied' is a specified, only deletes until +this object's 'unapplied' value is >= the specified amount. +(Deletes in order returned by L.) + +=cut + +sub delete_cust_bill_pay { + my $self = shift; + my %opt = @_; + + local $SIG{HUP} = 'IGNORE'; + local $SIG{INT} = 'IGNORE'; + local $SIG{QUIT} = 'IGNORE'; + local $SIG{TERM} = 'IGNORE'; + local $SIG{TSTP} = 'IGNORE'; + local $SIG{PIPE} = 'IGNORE'; + + my $oldAutoCommit = $FS::UID::AutoCommit; + local $FS::UID::AutoCommit = 0; + my $dbh = dbh; + + my $unapplied = $self->unapplied; #only need to look it up once + + my $error = ''; + + # Maybe we should reverse the order these get deleted in? + # ie delete newest first? + # keeping consistent with how bop refunds work, for now... + foreach my $cust_bill_pay ( $self->cust_bill_pay ) { + last if $opt{'unapplied'} && ($unapplied > $opt{'unapplied'}); + $unapplied += $cust_bill_pay->amount; + $error = $cust_bill_pay->delete; + last if $error; + } + + if ($error) { + $dbh->rollback if $oldAutoCommit; + return $error; + } + + $dbh->commit or die $dbh->errstr if $oldAutoCommit; + return ''; +} + +=item refund HASHREF + +Accepts input for creating a new FS::cust_refund object. +Unapplies payment from invoices up to the amount of the refund, +creates the refund and applies payment to refund. Allows entire +process to be handled in one transaction. + +Causes a fatal error if called on CARD or CHEK payments. + +=cut + +sub refund { + my $self = shift; + my $hash = shift; + die "Cannot call cust_pay->refund on " . $self->payby + if grep { $_ eq $self->payby } qw(CARD CHEK); + + local $SIG{HUP} = 'IGNORE'; + local $SIG{INT} = 'IGNORE'; + local $SIG{QUIT} = 'IGNORE'; + local $SIG{TERM} = 'IGNORE'; + local $SIG{TSTP} = 'IGNORE'; + local $SIG{PIPE} = 'IGNORE'; + + my $oldAutoCommit = $FS::UID::AutoCommit; + local $FS::UID::AutoCommit = 0; + my $dbh = dbh; + + my $error = $self->delete_cust_bill_pay('amount' => $hash->{'amount'}); + + if ($error) { + $dbh->rollback if $oldAutoCommit; + return $error; + } + + $hash->{'paynum'} = $self->paynum; + my $new = new FS::cust_refund ( $hash ); + $error = $new->insert; + + if ($error) { + $dbh->rollback if $oldAutoCommit; + return $error; + } + + $dbh->commit or die $dbh->errstr if $oldAutoCommit; + return ''; +} + +### refund_to_unapply/unapply_refund false laziness with FS::cust_credit + +=item refund_to_unapply + +Returns L objects that will be deleted by L +(all currently applied refunds that aren't closed.) +Returns empty list if payment itself is closed. + +=cut + +sub refund_to_unapply { + my $self = shift; + return () if $self->closed; + qsearch({ + 'table' => 'cust_pay_refund', + 'hashref' => { 'paynum' => $self->paynum }, + 'addl_from' => 'LEFT JOIN cust_refund USING (refundnum)', + 'extra_sql' => "AND cust_refund.closed IS NULL AND cust_refund.source_paynum IS NULL", + }); +} + +=item unapply_refund + +Deletes all objects returned by L. + +=cut + +sub unapply_refund { + my $self = shift; + + local $SIG{HUP} = 'IGNORE'; + local $SIG{INT} = 'IGNORE'; + local $SIG{QUIT} = 'IGNORE'; + local $SIG{TERM} = 'IGNORE'; + local $SIG{TSTP} = 'IGNORE'; + local $SIG{PIPE} = 'IGNORE'; + + my $oldAutoCommit = $FS::UID::AutoCommit; + local $FS::UID::AutoCommit = 0; + + foreach my $cust_pay_refund ($self->refund_to_unapply) { + my $error = $cust_pay_refund->delete; + if ($error) { + dbh->rollback if $oldAutoCommit; + return $error; + } + } + + dbh->commit or die dbh->errstr if $oldAutoCommit; + return ''; +} + =back =head1 CLASS METHODS @@ -843,7 +1099,7 @@ sub batch_insert { } } elsif ( !$error ) { #normal case: apply payments as usual - $cust_pay->cust_main->apply_payments; + $cust_pay->cust_main->apply_payments( 'manual'=>1 ); } } @@ -862,7 +1118,7 @@ sub batch_insert { Returns an SQL fragment to retreive the unapplied amount. -=cut +=cut sub unapplied_sql { my ($class, $start, $end) = @_; @@ -888,6 +1144,30 @@ sub unapplied_sql { } +=item SSAPI_getinfo + +=cut + +sub SSAPI_getinfo { + #my( $self, %opt ) = @_; + my $self = shift; + + +{ 'paynum' => $self->paynum, + '_date' => $self->_date, + 'date' => time2str("%b %o, %Y", $self->_date), + 'date_short' => time2str("%m-%d-%Y", $self->_date), + 'paid' => sprintf('%.2f', $self->paid), + 'payby' => $self->payby, + 'paycardtype' => $self->paycardtype, + 'paymask' => $self->paymask, + 'processor' => $self->processor, + 'auth' => $self->auth, + 'order_number' => $self->order_number, + }; + +} + + # _upgrade_data # # Used by FS::Upgrade to migrate to a new database. @@ -895,7 +1175,7 @@ sub unapplied_sql { use FS::h_cust_pay; sub _upgrade_data { #class method - my ($class, %opts) = @_; + my ($class, %opt) = @_; warn "$me upgrading $class\n" if $DEBUG; @@ -1009,17 +1289,72 @@ sub _upgrade_data { #class method ### delete $FS::payby::hash{'COMP'}->{cust_pay}; #quelle kludge - $class->_upgrade_otaker(%opts); + $class->_upgrade_otaker(%opt); $FS::payby::hash{'COMP'}->{cust_pay} = ''; #restore it + # if we do this anywhere else, it should become an FS::Upgrade method + my $num_to_upgrade = $class->count('paybatch is not null'); + my $num_jobs = FS::queue->count('job = \'FS::cust_pay::process_upgrade_paybatch\' and status != \'failed\''); + if ( $num_to_upgrade > 0 ) { + warn "Need to migrate paybatch field in $num_to_upgrade payments.\n"; + if ( $opt{queue} ) { + if ( $num_jobs > 0 ) { + warn "Upgrade already queued.\n"; + } else { + warn "Scheduling upgrade.\n"; + my $job = FS::queue->new({ job => 'FS::cust_pay::process_upgrade_paybatch' }); + $job->insert; + } + } else { + process_upgrade_paybatch(); + } + } + + ### + # don't set paycardtype until 4.x + ### + #$class->upgrade_set_cardtype; + + # for batch payments, make sure paymask is set + do { + local $FS::payinfo_Mixin::allow_closed_replace = 1; + local $FS::payinfo_Mixin::ignore_masked_payinfo = 1; + + my $cursor = FS::Cursor->new({ + table => 'cust_pay', + extra_sql => ' WHERE paymask IS NULL AND payinfo IS NOT NULL + AND payby IN(\'CARD\', \'CHEK\') + AND batchnum IS NOT NULL', + }); + + # records from cursors for some reason don't decrypt payinfo, so + # call replace_old to fetch the record "normally" + while (my $cust_pay = $cursor->fetch) { + $cust_pay = $cust_pay->replace_old; + $cust_pay->set('paymask', $cust_pay->mask_payinfo); + my $error = $cust_pay->replace; + if ($error) { + die "$error (setting masked payinfo on payment#". $cust_pay->paynum. + ")\n" + } + } + }; +} + +sub process_upgrade_paybatch { + my $dbh = dbh; + local $FS::payinfo_Mixin::ignore_masked_payinfo = 1; + local $FS::UID::AutoCommit = 1; + ### # migrate batchnums from the misused 'paybatch' field to 'batchnum' ### - my @cust_pay = qsearch( { - 'table' => 'cust_pay', - 'addl_from' => ' JOIN pay_batch ON cust_pay.paybatch = CAST(pay_batch.batchnum AS text) ', + my $text = (driver_name =~ /^mysql/i) ? 'char' : 'text'; + my $search = FS::Cursor->new( { + 'table' => 'cust_pay', + 'addl_from' => " JOIN pay_batch ON cust_pay.paybatch = CAST(pay_batch.batchnum AS $text) ", } ); - foreach my $cust_pay (@cust_pay) { + while (my $cust_pay = $search->fetch) { $cust_pay->set('batchnum' => $cust_pay->paybatch); $cust_pay->set('paybatch' => ''); my $error = $cust_pay->replace; @@ -1038,14 +1373,16 @@ sub _upgrade_data { #class method foreach my $table (qw(cust_pay cust_pay_void cust_refund)) { my $and_batchnum_is_null = ( $table =~ /^cust_pay/ ? ' AND batchnum IS NULL' : '' ); - foreach my $object ( qsearch({ - table => $table, - extra_sql => "WHERE payby IN('CARD','CHEK') ". - "AND (paybatch IS NOT NULL ". - "OR (paybatch IS NULL AND auth IS NULL - $and_batchnum_is_null ) )", - }) ) - { + my $pkey = ($table =~ /^cust_pay/ ? 'paynum' : 'refundnum'); + my $search = FS::Cursor->new({ + table => $table, + extra_sql => "WHERE payby IN('CARD','CHEK') ". + "AND (paybatch IS NOT NULL ". + "OR (paybatch IS NULL AND auth IS NULL + $and_batchnum_is_null ) ) + ORDER BY $pkey DESC" + }); + while ( my $object = $search->fetch ) { if ( $object->paybatch eq '' ) { # repair for a previous upgrade that didn't save 'auth' my $pkey = $object->primary_key; @@ -1092,6 +1429,89 @@ sub _upgrade_data { #class method =over 4 +=item process_batch_import + +=cut + +sub process_batch_import { + my $job = shift; + + my $hashcb = sub { + my %hash = @_; + my $custnum = $hash{'custnum'}; + my $agentnum = $hash{'agentnum'}; + my $agent_custid = $hash{'agent_custid'}; + #standardize date + $hash{'_date'} = parse_datetime($hash{'_date'}) + if $hash{'_date'} && $hash{'_date'} =~ /\D/; + #remove custnum_prefix + my $custnum_prefix = $conf->config('cust_main-custnum-display_prefix'); + my $custnum_length = $conf->config('cust_main-custnum-display_length') || 8; + if ( + $custnum_prefix + && $custnum =~ /^$custnum_prefix(0*([1-9]\d*))$/ + && length($1) == $custnum_length + ) { + $custnum = $2; + } + # check agentnum against custnum and + # translate agent_custid into regular custnum + if ($custnum && $agent_custid) { + die "can't specify both custnum and agent_custid\n"; + } elsif ($agentnum || $agent_custid) { + # here is the agent virtualization + my $extra_sql = ' AND '. $FS::CurrentUser::CurrentUser->agentnums_sql; + my %search; + $search{'agentnum'} = $agentnum + if $agentnum; + $search{'agent_custid'} = $agent_custid + if $agent_custid; + $search{'custnum'} = $custnum + if $custnum; + my $cust_main = qsearchs({ + 'table' => 'cust_main', + 'hashref' => \%search, + 'extra_sql' => $extra_sql, + }); + die "can't find customer with" . + ($agentnum ? " agentnum $agentnum" : '') . + ($custnum ? " custnum $custnum" : '') . + ($agent_custid ? " agent_custid $agent_custid" : '') . "\n" + unless $cust_main; + die "mismatched customer number\n" + if $custnum && ($custnum ne $cust_main->custnum); + $custnum = $cust_main->custnum; + } + $hash{'custnum'} = $custnum; + delete($hash{'agent_custid'}); + return %hash; + }; + + my $opt = { + 'table' => 'cust_pay', + 'params' => [ '_date', 'agentnum', 'payby', 'paybatch' ], + #agent_custid isn't a cust_pay field, see hash callback + 'formats' => { 'simple' => + [ qw(custnum agent_custid paid payinfo invnum) ] }, + 'format_types' => { 'simple' => '' }, #force infer from file extension + 'default_csv' => 1, #if not .xls, will read as csv, regardless of extension + 'format_hash_callbacks' => { 'simple' => $hashcb }, + 'insert_args_callback' => sub { ( 'manual'=>1 ); }, + 'postinsert_callback' => sub { + my $cust_pay = shift; + my $cust_main = $cust_pay->cust_main + or return "can't find customer to which payments apply"; + my $error = $cust_main->apply_payments_and_credits( 'manual'=>1 ); + return $error + ? "can't apply payments to customer ".$cust_pay->custnum."$error" + : ''; + }, + }; + + FS::Record::process_batch_import( $job, $opt, @_ ); + +} + =item batch_import HASHREF Inserts new payments. @@ -1101,18 +1521,24 @@ Inserts new payments. sub batch_import { my $param = shift; - my $fh = $param->{filehandle}; + my $fh = $param->{filehandle}; + my $format = $param->{'format'}; + my $agentnum = $param->{agentnum}; - my $format = $param->{'format'}; + my $_date = $param->{_date}; + $_date = parse_datetime($_date) if $_date && $_date =~ /\D/; my $paybatch = $param->{'paybatch'}; + my $custnum_prefix = $conf->config('cust_main-custnum-display_prefix'); + my $custnum_length = $conf->config('cust_main-custnum-display_length') || 8; + # here is the agent virtualization my $extra_sql = ' AND '. $FS::CurrentUser::CurrentUser->agentnums_sql; my @fields; my $payby; if ( $format eq 'simple' ) { - @fields = qw( custnum agent_custid paid payinfo ); + @fields = qw( custnum agent_custid paid payinfo invnum ); $payby = 'BILL'; } elsif ( $format eq 'extended' ) { die "unimplemented\n"; @@ -1154,6 +1580,7 @@ sub batch_import { payby => $payby, paybatch => $paybatch, ); + $cust_pay{_date} = $_date if $_date; my $cust_main; foreach my $field ( @fields ) { @@ -1191,9 +1618,25 @@ sub batch_import { $cust_pay{$field} = shift @columns; } + if ( $custnum_prefix && $cust_pay{custnum} =~ /^$custnum_prefix(0*([1-9]\d*))$/ + && length($1) == $custnum_length ) { + $cust_pay{custnum} = $2; + } + + my $custnum = $cust_pay{custnum}; + my $cust_pay = new FS::cust_pay( \%cust_pay ); my $error = $cust_pay->insert; + if ( ! $error && $cust_pay->custnum != $custnum ) { + #invnum was defined, and ->insert set custnum to the customer for that + #invoice, but it wasn't the one the import specified. + $dbh->rollback if $oldAutoCommit; + $error = "specified invoice #". $cust_pay{invnum}. + " is for custnum ". $cust_pay->custnum. + ", not specified custnum $custnum"; + } + if ( $error ) { $dbh->rollback if $oldAutoCommit; return "can't insert payment for $line: $error";