X-Git-Url: http://wagnertech.de/git?a=blobdiff_plain;f=SL%2FController%2FBankTransaction.pm;h=2b338318f9f54d5a18e525c696a4cb57aa7cf63e;hb=e83fcf3aa3394efdf2293ea60d5510fcfbf41b52;hp=6b51c246360555747590ebfedd4bd82036ef6d02;hpb=031566ec011c921c54d114a122181e2418025619;p=kivitendo-erp.git diff --git a/SL/Controller/BankTransaction.pm b/SL/Controller/BankTransaction.pm index 6b51c2463..2b338318f 100644 --- a/SL/Controller/BankTransaction.pm +++ b/SL/Controller/BankTransaction.pm @@ -20,6 +20,7 @@ use SL::DB::RecordLink; use SL::JSON; use SL::DB::Chart; use SL::DB::AccTransaction; +use SL::DB::BankTransactionAccTrans; use SL::DB::Tax; use SL::DB::BankAccount; use SL::DB::RecordTemplate; @@ -28,7 +29,6 @@ use SL::DBUtils qw(like); use List::UtilsBy qw(partition_by); use List::MoreUtils qw(any); -use List::MoreUtils qw(any none); use List::Util qw(max); use Rose::Object::MakeMethods::Generic @@ -99,6 +99,7 @@ sub action_list { where => [ amount => {ne => \'invoice_amount'}, local_bank_account_id => $::form->{filter}{bank_account}, + cleared => 0, @where ], ); @@ -129,7 +130,8 @@ sub action_list { $open_invoice->{skonto_type} = 'without_skonto'; foreach (@{ $sepa_export_items_by_id{ $open_invoice->id } || [] }) { my $factor = ($_->ar_id == $open_invoice->id ? 1 : -1); - $open_invoice->{realamount} = $::form->format_sellprice($open_invoice->amount*$factor); + $open_invoice->{realamount} = $::form->format_amount(\%::myconfig,$open_invoice->amount*$factor,2); + $open_invoice->{skonto_type} = $_->payment_type; $sepa_exports{$_->sepa_export_id} ||= { count => 0, is_ar => 0, amount => 0, proposed => 0, invoices => [], item => $_ }; $sepa_exports{$_->sepa_export_id}->{count}++; @@ -182,7 +184,9 @@ sub action_list { # score is stored in $bt->{agreement} foreach my $open_invoice (@all_open_invoices) { - ($open_invoice->{agreement}, $open_invoice->{rule_matches}) = $bt->get_agreement_with_invoice($open_invoice); + ($open_invoice->{agreement}, $open_invoice->{rule_matches}) = $bt->get_agreement_with_invoice($open_invoice, + sepa_export_items => $all_open_sepa_export_items, + ); $open_invoice->{realamount} = $::form->format_amount(\%::myconfig, $open_invoice->amount * ($open_invoice->{is_ar} ? 1 : -1), 2); } @@ -231,7 +235,7 @@ sub action_list { # for testing with t/bank/banktransaction.t : if ( $::form->{dont_render_for_test} ) { - return $bank_transactions; + return ( $bank_transactions , \@proposals ); } $::request->layout->add_javascripts("kivi.BankTransaction.js"); @@ -260,12 +264,6 @@ sub action_create_invoice { $self->transaction(SL::DB::Manager::BankTransaction->find_by(id => $::form->{bt_id})); - # This was dead code: We compared vendor.account_name with bank_transaction.iban. - # This did never match (Kontonummer != IBAN). It's kivis 09/02 (2013) day - # If refactored/improved, also consider that vendor.iban should be normalized - # user may like to input strings like: 'AT 3333 3333 2222 1111' -> can be checked strictly - # at Vendor code because we need the correct data for all sepa exports. - my $vendor_of_transaction = SL::DB::Manager::Vendor->find_by(iban => $self->transaction->{remote_account_number}); my $use_vendor_filter = $self->transaction->{remote_account_number} && $vendor_of_transaction; @@ -558,13 +556,16 @@ sub save_single_bank_transaction { }; } + my $bank_transaction = $data{bank_transaction}; + my (@warnings); my $worker = sub { my $bt_id = $data{bank_transaction_id}; - my $bank_transaction = $data{bank_transaction}; my $sign = $bank_transaction->amount < 0 ? -1 : 1; my $amount_of_transaction = $sign * $bank_transaction->amount; + my $assigned_amount = $sign * $bank_transaction->invoice_amount; + my $not_assigned_amount = $amount_of_transaction - $assigned_amount; my $payment_received = $bank_transaction->amount > 0; my $payment_sent = $bank_transaction->amount < 0; @@ -612,15 +613,6 @@ sub save_single_bank_transaction { $n_invoices++ ; - # Check if bank_transaction already has a link to the invoice, may only be linked once per invoice - # This might be caused by the user reloading a page and resending the form - if (_existing_record_link($bank_transaction, $invoice)) { - return { - %data, - result => 'error', - message => $::locale->text("Bank transaction with id #1 has already been linked to #2.", $bank_transaction->id, $invoice->displayable_name), - }; - } if (!$amount_of_transaction && $invoice->open_amount) { return { @@ -636,73 +628,49 @@ sub save_single_bank_transaction { } else { $payment_type = 'without_skonto'; }; - - - # pay invoice or go to the next bank transaction if the amount is not sufficiently high - if ($invoice->open_amount <= $amount_of_transaction && $n_invoices < $max_invoices) { - my $open_amount = ($payment_type eq 'with_skonto_pt'?$invoice->amount_less_skonto:$invoice->open_amount); - # first calculate new bank transaction amount ... - if ($invoice->is_sales) { - $amount_of_transaction -= $sign * $open_amount; - $bank_transaction->invoice_amount($bank_transaction->invoice_amount + $open_amount); - } else { - $amount_of_transaction += $sign * $open_amount; - $bank_transaction->invoice_amount($bank_transaction->invoice_amount - $open_amount); - } - # ... and then pay the invoice - $invoice->pay_invoice(chart_id => $bank_transaction->local_bank_account->chart_id, - trans_id => $invoice->id, - amount => $open_amount, - payment_type => $payment_type, - source => $source, - memo => $memo, - transdate => $bank_transaction->transdate->to_kivitendo); - } else { - # use the whole amount of the bank transaction for the invoice, overpay the invoice if necessary - - # this catches credit_notes and negative sales invoices - if ( $invoice->is_sales && $invoice->amount < 0 ) { - # $invoice->open_amount is negative for credit_notes - # $bank_transaction->amount is negative for outgoing transactions - # so $amount_of_transaction is negative but needs positive - $amount_of_transaction *= -1; - - } elsif (!$invoice->is_sales && $invoice->invoice_type =~ m/ap_transaction|purchase_invoice/) { - # $invoice->open_amount may be negative for ap_transaction but may be positiv for negativ ap_transaction - # if $invoice->open_amount is negative $bank_transaction->amount is positve - # if $invoice->open_amount is positive $bank_transaction->amount is negative - # but amount of transaction is for both positive - $amount_of_transaction *= -1 if $invoice->open_amount == - $amount_of_transaction; - } - - my $overpaid_amount = $amount_of_transaction - $invoice->open_amount; - $invoice->pay_invoice(chart_id => $bank_transaction->local_bank_account->chart_id, - trans_id => $invoice->id, - amount => $amount_of_transaction, - payment_type => $payment_type, - source => $source, - memo => $memo, - transdate => $bank_transaction->transdate->to_kivitendo); - $bank_transaction->invoice_amount($bank_transaction->amount); - $amount_of_transaction = 0; - - if ($overpaid_amount >= 0.01) { - push @warnings, { - %data, - result => 'warning', - message => $::locale->text('Invoice #1 was overpaid by #2.', $invoice->invnumber, $::form->format_amount(\%::myconfig, $overpaid_amount, 2)), - }; - } - } + # pay invoice + # TODO rewrite this: really booked amount should be a return value of Payment.pm + # also this controller shouldnt care about how to calc skonto. we simply delegate the + # payment_type to the helper and get the corresponding bank_transaction values back + + my $open_amount = ($payment_type eq 'with_skonto_pt' ? $invoice->amount_less_skonto : $invoice->open_amount); + my $amount_for_booking = abs(($open_amount < $not_assigned_amount) ? $open_amount : $not_assigned_amount); + $amount_for_booking *= $sign; + $bank_transaction->invoice_amount($bank_transaction->invoice_amount + $amount_for_booking); + + # ... and then pay the invoice + my @acc_ids = $invoice->pay_invoice(chart_id => $bank_transaction->local_bank_account->chart_id, + trans_id => $invoice->id, + amount => ($open_amount < $not_assigned_amount) ? $open_amount : $not_assigned_amount, + payment_type => $payment_type, + source => $source, + memo => $memo, + transdate => $bank_transaction->transdate->to_kivitendo); + # ... and record the origin via BankTransactionAccTrans + if (scalar(@acc_ids) != 2) { + return { + %data, + result => 'error', + message => $::locale->text("Unable to book transactions for bank purpose #1", $bank_transaction->purpose), + }; + } + foreach my $acc_trans_id (@acc_ids) { + my $id_type = $invoice->is_sales ? 'ar' : 'ap'; + my %props_acc = ( + acc_trans_id => $acc_trans_id, + bank_transaction_id => $bank_transaction->id, + $id_type => $invoice->id, + ); + SL::DB::BankTransactionAccTrans->new(%props_acc)->save; + } # Record a record link from the bank transaction to the invoice - my @props = ( + my %props = ( from_table => 'bank_transactions', from_id => $bt_id, to_table => $invoice->is_sales ? 'ar' : 'ap', to_id => $invoice->id, ); - - SL::DB::RecordLink->new(@props)->save; + SL::DB::RecordLink->new(%props)->save; # "close" a sepa_export_item if it exists # code duplicated in action_save_proposals! @@ -738,6 +706,9 @@ sub save_single_bank_transaction { # Rollback Fehler nicht weiterreichen # die if $error; + # aber einen rollback von hand + $::lxdebug->message(LXDebug->DEBUG2(),"finish worker with ". ($error ? $error->{result} : '-')); + $data{bank_transaction}->db->dbh->rollback if $error && $error->{result} eq 'error'; }); return grep { $_ } ($error, @warnings); @@ -798,7 +769,8 @@ sub prepare_report { align => 'right' }, invoice_amount => { sub => sub { $_[0]->invoice_amount_as_number }, align => 'right' }, - invoices => { sub => sub { $_[0]->linked_invoices } }, + invoices => { sub => sub { my @invnumbers; for my $obj (@{ $_[0]->linked_invoices }) { + next unless $obj; push @invnumbers, $obj->invnumber } return \@invnumbers } }, currency => { sub => sub { $_[0]->currency->name } }, purpose => { }, local_account_number => { sub => sub { $_[0]->local_bank_account->account_number } }, @@ -833,20 +805,6 @@ sub prepare_report { ); } -sub _existing_record_link { - my ($bt, $invoice) = @_; - - # check whether a record link from banktransaction $bt already exists to - # invoice $invoice, returns 1 if that is the case - - die unless $bt->isa("SL::DB::BankTransaction") && ( $invoice->isa("SL::DB::Invoice") || $invoice->isa("SL::DB::PurchaseInvoice") ); - - my $linked_record_to_table = $invoice->is_sales ? 'Invoice' : 'PurchaseInvoice'; - my $linked_records = $bt->linked_records( direction => 'to', to => $linked_record_to_table, query => [ id => $invoice->id ] ); - - return @$linked_records ? 1 : 0; -}; - sub init_problems { [] } sub init_models { @@ -901,9 +859,11 @@ sub load_gl_record_template_url { controller => 'gl.pl', action => 'load_record_template', id => $template->id, - 'form_defaults.amount_1' => abs($self->transaction->amount), # always positive + 'form_defaults.amount_1' => abs($self->transaction->not_assigned_amount), # always positive 'form_defaults.transdate' => $self->transaction->transdate_as_date, 'form_defaults.callback' => $self->callback, + 'form_defaults.bt_id' => $self->transaction->id, + 'form_defaults.bt_chart_id' => $self->transaction->local_bank_account->chart->id, ); } @@ -958,6 +918,16 @@ tries to post its amount to a certain number of invoices (parameter C, an array ref of database IDs to purchase or sales invoice objects). +This method handles already partly assigned bank transactions. + +This method cannot handle already partly assigned bank transactions, i.e. +a bank transaction that has a invoice_amount <> 0 but not the fully +transaction amount (invoice_amount == amount). + +If the amount of the bank transaction is higher than the sum of +the assigned invoices (1 .. n) the bank transaction will only be +partly assigned. + The whole function is wrapped in a database transaction. If an exception occurs the bank transaction is not posted at all. The same is true if the code detects an error during the execution, e.g. a bank