marei: new koma-names + fallback for outdated versions
[kivitendo-erp.git] / SL / Controller / BankTransaction.pm
1 package SL::Controller::BankTransaction;
2
3 # idee- möglichkeit bankdaten zu übernehmen in stammdaten
4 # erst Kontenabgleich, um alle gl-Einträge wegzuhaben
5 use strict;
6
7 use parent qw(SL::Controller::Base);
8
9 use SL::Controller::Helper::GetModels;
10 use SL::Controller::Helper::ReportGenerator;
11 use SL::ReportGenerator;
12
13 use SL::DB::BankTransaction;
14 use SL::Helper::Flash;
15 use SL::Locale::String;
16 use SL::SEPA;
17 use SL::DB::Invoice;
18 use SL::DB::PurchaseInvoice;
19 use SL::DB::RecordLink;
20 use SL::DB::ReconciliationLink;
21 use SL::JSON;
22 use SL::DB::Chart;
23 use SL::DB::AccTransaction;
24 use SL::DB::BankTransactionAccTrans;
25 use SL::DB::Tax;
26 use SL::DB::BankAccount;
27 use SL::DB::GLTransaction;
28 use SL::DB::RecordTemplate;
29 use SL::DB::SepaExportItem;
30 use SL::DBUtils qw(like do_query);
31
32 use SL::Presenter::Tag qw(checkbox_tag html_tag);
33 use Carp;
34 use List::UtilsBy qw(partition_by);
35 use List::MoreUtils qw(any);
36 use List::Util qw(max);
37
38 use Rose::Object::MakeMethods::Generic
39 (
40   scalar                  => [ qw(callback transaction) ],
41   'scalar --get_set_init' => [ qw(models problems) ],
42 );
43
44 __PACKAGE__->run_before('check_auth');
45
46
47 #
48 # actions
49 #
50
51 sub action_search {
52   my ($self) = @_;
53
54   my $bank_accounts = SL::DB::Manager::BankAccount->get_all_sorted( query => [ obsolete => 0 ] );
55
56   $self->setup_search_action_bar;
57   $self->render('bank_transactions/search',
58                  BANK_ACCOUNTS => $bank_accounts);
59 }
60
61 sub action_list_all {
62   my ($self) = @_;
63
64   $self->make_filter_summary;
65   $self->prepare_report;
66
67   $self->setup_list_all_action_bar;
68   $self->report_generator_list_objects(report => $self->{report}, objects => $self->models->get);
69 }
70
71 sub gather_bank_transactions_and_proposals {
72   my ($self, %params) = @_;
73
74   my $sort_by = $params{sort_by} || 'transdate';
75   $sort_by = 'transdate' if $sort_by eq 'proposal';
76   $sort_by .= $params{sort_dir} ? ' DESC' : ' ASC';
77
78   my @where = ();
79   push @where, (transdate => { ge => $params{fromdate} }) if $params{fromdate};
80   push @where, (transdate => { lt => $params{todate} })   if $params{todate};
81   # bank_transactions no younger than starting date,
82   # including starting date (same search behaviour as fromdate)
83   # but OPEN invoices to be matched may be from before
84   if ( $params{bank_account}->reconciliation_starting_date ) {
85     push @where, (transdate => { ge => $params{bank_account}->reconciliation_starting_date });
86   };
87
88   my $bank_transactions = SL::DB::Manager::BankTransaction->get_all(
89     with_objects => [ 'local_bank_account', 'currency' ],
90     sort_by      => $sort_by,
91     limit        => 10000,
92     where        => [
93       amount                => {ne => \'invoice_amount'},
94       local_bank_account_id => $params{bank_account}->id,
95       cleared               => 0,
96       @where
97     ],
98   );
99   # credit notes have a negative amount, treat differently
100   my $all_open_ar_invoices = SL::DB::Manager::Invoice        ->get_all(where => [ or => [ amount => { gt => \'paid' },
101                                                                                           and => [ type    => 'credit_note',
102                                                                                                    amount  => { lt => \'paid' }
103                                                                                                  ],
104                                                                                         ],
105                                                                                 ],
106                                                                        with_objects => ['customer','payment_terms']);
107
108   my $all_open_ap_invoices = SL::DB::Manager::PurchaseInvoice->get_all(where => [amount => { ne => \'paid' }], with_objects => ['vendor'  ,'payment_terms']);
109   my $all_open_sepa_export_items = SL::DB::Manager::SepaExportItem->get_all(where => [chart_id => $params{bank_account}->chart_id ,
110                                                                              'sepa_export.executed' => 0, 'sepa_export.closed' => 0 ], with_objects => ['sepa_export']);
111
112   my @all_open_invoices;
113   # filter out invoices with less than 1 cent outstanding
114   push @all_open_invoices, map { $_->{is_ar}=1 ; $_ } grep { abs($_->amount - $_->paid) >= 0.01 } @{ $all_open_ar_invoices };
115   push @all_open_invoices, map { $_->{is_ar}=0 ; $_ } grep { abs($_->amount - $_->paid) >= 0.01 } @{ $all_open_ap_invoices };
116
117   my %sepa_exports;
118   my %sepa_export_items_by_id = partition_by { $_->ar_id || $_->ap_id } @$all_open_sepa_export_items;
119
120   # first collect sepa export items to open invoices
121   foreach my $open_invoice (@all_open_invoices){
122     $open_invoice->{realamount}  = $::form->format_amount(\%::myconfig,$open_invoice->amount,2);
123     $open_invoice->{skonto_type} = 'without_skonto';
124     foreach (@{ $sepa_export_items_by_id{ $open_invoice->id } || [] }) {
125       my $factor                   = ($_->ar_id == $open_invoice->id ? 1 : -1);
126       $open_invoice->{realamount}  = $::form->format_amount(\%::myconfig,$open_invoice->amount*$factor,2);
127
128       $open_invoice->{skonto_type} = $_->payment_type;
129       $sepa_exports{$_->sepa_export_id} ||= { count => 0, is_ar => 0, amount => 0, proposed => 0, invoices => [], item => $_ };
130       $sepa_exports{$_->sepa_export_id}->{count}++;
131       $sepa_exports{$_->sepa_export_id}->{is_ar}++ if  $_->ar_id == $open_invoice->id;
132       $sepa_exports{$_->sepa_export_id}->{amount} += $_->amount * $factor;
133       push @{ $sepa_exports{$_->sepa_export_id}->{invoices} }, $open_invoice;
134     }
135   }
136
137   # try to match each bank_transaction with each of the possible open invoices
138   # by awarding points
139   my @proposals;
140
141   foreach my $bt (@{ $bank_transactions }) {
142     ## 5 Stellen hinter dem Komma auf 2 Stellen reduzieren
143     $bt->amount($bt->amount*1);
144     $bt->invoice_amount($bt->invoice_amount*1);
145
146     $bt->{proposals}    = [];
147     $bt->{rule_matches} = [];
148
149     $bt->{remote_name} .= $bt->{remote_name_1} if $bt->{remote_name_1};
150
151     if ( $bt->is_batch_transaction ) {
152       my $found=0;
153       foreach ( keys  %sepa_exports) {
154         if ( abs(($sepa_exports{$_}->{amount} * 1) - ($bt->amount * 1)) < 0.01 ) {
155           ## jupp
156           @{$bt->{proposals}} = @{$sepa_exports{$_}->{invoices}};
157           $bt->{sepa_export_ok} = 1;
158           $sepa_exports{$_}->{proposed}=1;
159           push(@proposals, $bt);
160           $found=1;
161           last;
162         }
163       }
164       next if $found;
165       # batch transaction has no remotename !!
166     } else {
167       next unless $bt->{remote_name};  # bank has no name, usually fees, use create invoice to assign
168     }
169
170     # try to match the current $bt to each of the open_invoices, saving the
171     # results of get_agreement_with_invoice in $open_invoice->{agreement} and
172     # $open_invoice->{rule_matches}.
173
174     # The values are overwritten each time a new bt is checked, so at the end
175     # of each bt the likely results are filtered and those values are stored in
176     # the arrays $bt->{proposals} and $bt->{rule_matches}, and the agreement
177     # score is stored in $bt->{agreement}
178
179     foreach my $open_invoice (@all_open_invoices) {
180       ($open_invoice->{agreement}, $open_invoice->{rule_matches}) = $bt->get_agreement_with_invoice($open_invoice,
181         sepa_export_items => $all_open_sepa_export_items,
182       );
183       $open_invoice->{realamount} = $::form->format_amount(\%::myconfig,
184                                       $open_invoice->amount * ($open_invoice->{is_ar} ? 1 : -1), 2);
185     }
186
187     my $agreement = 15;
188     my $min_agreement = 3; # suggestions must have at least this score
189
190     my $max_agreement = max map { $_->{agreement} } @all_open_invoices;
191
192     # add open_invoices with highest agreement into array $bt->{proposals}
193     if ( $max_agreement >= $min_agreement ) {
194       $bt->{proposals} = [ grep { $_->{agreement} == $max_agreement } @all_open_invoices ];
195       $bt->{agreement} = $max_agreement; #scalar @{ $bt->{proposals} } ? $agreement + 1 : '';
196
197       # store the rule_matches in a separate array, so they can be displayed in template
198       foreach ( @{ $bt->{proposals} } ) {
199         push(@{$bt->{rule_matches}}, $_->{rule_matches});
200       };
201     };
202   }  # finished one bt
203   # finished all bt
204
205   # separate filter for proposals (second tab, agreement >= 5 and exactly one match)
206   # to qualify as a proposal there has to be
207   # * agreement >= 5  TODO: make threshold configurable in configuration
208   # * there must be only one exact match
209   # * depending on whether sales or purchase the amount has to have the correct sign (so Gutschriften don't work?)
210   my $proposal_threshold = 5;
211   my @otherproposals = grep {
212        ($_->{agreement} >= $proposal_threshold)
213     && (1 == scalar @{ $_->{proposals} })
214     && (@{ $_->{proposals} }[0]->is_sales ? abs(@{ $_->{proposals} }[0]->amount - $_->amount) < 0.01
215                                           : abs(@{ $_->{proposals} }[0]->amount + $_->amount) < 0.01)
216   } @{ $bank_transactions };
217
218   push @proposals, @otherproposals;
219
220   # sort bank transaction proposals by quality (score) of proposal
221   if ($params{sort_by} && $params{sort_by} eq 'proposal') {
222     my $dir = $params{sort_dir} ? 1 : -1;
223     $bank_transactions = [ sort { ($a->{agreement} <=> $b->{agreement}) * $dir } @{ $bank_transactions } ];
224   }
225
226   return ( $bank_transactions , \@proposals );
227 }
228
229 sub action_list {
230   my ($self) = @_;
231
232   if (!$::form->{filter}{bank_account}) {
233     flash('error', t8('No bank account chosen!'));
234     $self->action_search;
235     return;
236   }
237
238   my $bank_account = SL::DB::BankAccount->load_cached($::form->{filter}->{bank_account});
239   my $fromdate     = $::locale->parse_date_to_object($::form->{filter}->{fromdate});
240   my $todate       = $::locale->parse_date_to_object($::form->{filter}->{todate});
241   $todate->add( days => 1 ) if $todate;
242
243   my ($bank_transactions, $proposals) = $self->gather_bank_transactions_and_proposals(
244     bank_account => $bank_account,
245     fromdate     => $fromdate,
246     todate       => $todate,
247     sort_by      => $::form->{sort_by},
248     sort_dir     => $::form->{sort_dir},
249   );
250
251   $::request->layout->add_javascripts("kivi.BankTransaction.js");
252   $self->render('bank_transactions/list',
253                 title             => t8('Bank transactions MT940'),
254                 BANK_TRANSACTIONS => $bank_transactions,
255                 PROPOSALS         => $proposals,
256                 bank_account      => $bank_account,
257                 ui_tab            => scalar(@{ $proposals }) > 0 ? 1 : 0,
258               );
259 }
260
261 sub action_assign_invoice {
262   my ($self) = @_;
263
264   $self->{transaction} = SL::DB::Manager::BankTransaction->find_by(id => $::form->{bt_id});
265
266   $self->render('bank_transactions/assign_invoice',
267                 { layout => 0 },
268                 title => t8('Assign invoice'),);
269 }
270
271 sub action_create_invoice {
272   my ($self) = @_;
273   my %myconfig = %main::myconfig;
274
275   $self->transaction(SL::DB::Manager::BankTransaction->find_by(id => $::form->{bt_id}));
276
277   my $vendor_of_transaction = SL::DB::Manager::Vendor->find_by(iban => $self->transaction->{remote_account_number});
278   my $use_vendor_filter     = $self->transaction->{remote_account_number} && $vendor_of_transaction;
279
280   my $templates_ap = SL::DB::Manager::RecordTemplate->get_all(
281     where        => [ template_type => 'ap_transaction' ],
282     with_objects => [ qw(employee vendor) ],
283   );
284   my $templates_gl = SL::DB::Manager::RecordTemplate->get_all(
285     query        => [ template_type => 'gl_transaction',
286                       chart_id      => SL::DB::Manager::BankAccount->find_by(id => $self->transaction->local_bank_account_id)->chart_id,
287                     ],
288     with_objects => [ qw(employee record_template_items) ],
289   );
290
291   # pre filter templates_ap, if we have a vendor match (IBAN eq IBAN) - show and allow user to edit this via gui!
292   $templates_ap = [ grep { $_->vendor_id == $vendor_of_transaction->id } @{ $templates_ap } ] if $use_vendor_filter;
293
294   $self->callback($self->url_for(
295     action                => 'list',
296     'filter.bank_account' => $::form->{filter}->{bank_account},
297     'filter.todate'       => $::form->{filter}->{todate},
298     'filter.fromdate'     => $::form->{filter}->{fromdate},
299   ));
300
301   $self->render(
302     'bank_transactions/create_invoice',
303     { layout => 0 },
304     title        => t8('Create invoice'),
305     TEMPLATES_GL => $use_vendor_filter && @{ $templates_ap } ? undef : $templates_gl,
306     TEMPLATES_AP => $templates_ap,
307     vendor_name  => $use_vendor_filter && @{ $templates_ap } ? $vendor_of_transaction->name : undef,
308   );
309 }
310
311 sub action_ajax_payment_suggestion {
312   my ($self) = @_;
313
314   # based on a BankTransaction ID and a Invoice or PurchaseInvoice ID passed via $::form,
315   # create an HTML blob to be used by the js function add_invoices in templates/webpages/bank_transactions/list.html
316   # and return encoded as JSON
317
318   croak("Need bt_id") unless $::form->{bt_id};
319
320   my $invoice = SL::DB::Manager::Invoice->find_by( id => $::form->{prop_id} ) || SL::DB::Manager::PurchaseInvoice->find_by( id => $::form->{prop_id} );
321
322   croak("No valid invoice found") unless $invoice;
323
324   my $html = $self->render(
325     'bank_transactions/_payment_suggestion', { output => 0 },
326     bt_id          => $::form->{bt_id},
327     invoice        => $invoice,
328   );
329
330   $self->render(\ SL::JSON::to_json( { 'html' => "$html" } ), { layout => 0, type => 'json', process => 0 });
331 };
332
333 sub action_filter_templates {
334   my ($self) = @_;
335
336   $self->{transaction}      = SL::DB::Manager::BankTransaction->find_by(id => $::form->{bt_id});
337
338   my (@filter, @filter_ap);
339
340   # filter => gl and ap | filter_ap = ap (i.e. vendorname)
341   push @filter,    ('template_name' => { ilike => '%' . $::form->{template} . '%' })  if $::form->{template};
342   push @filter,    ('reference'     => { ilike => '%' . $::form->{reference} . '%' }) if $::form->{reference};
343   push @filter_ap, ('vendor.name'   => { ilike => '%' . $::form->{vendor} . '%' })    if $::form->{vendor};
344   push @filter_ap, @filter;
345   my $templates_gl = SL::DB::Manager::RecordTemplate->get_all(
346     query        => [ template_type => 'gl_transaction',
347                       chart_id      => SL::DB::Manager::BankAccount->find_by(id => $self->transaction->local_bank_account_id)->chart_id,
348                       (and => \@filter) x !!@filter
349                     ],
350     with_objects => [ qw(employee record_template_items) ],
351   );
352
353   my $templates_ap = SL::DB::Manager::RecordTemplate->get_all(
354     where        => [ template_type => 'ap_transaction', (and => \@filter_ap) x !!@filter_ap ],
355     with_objects => [ qw(employee vendor) ],
356   );
357   $::form->{filter} //= {};
358
359   $self->callback($self->url_for(
360     action                => 'list',
361     'filter.bank_account' => $::form->{filter}->{bank_account},
362     'filter.todate'       => $::form->{filter}->{todate},
363     'filter.fromdate'     => $::form->{filter}->{fromdate},
364   ));
365
366   my $output  = $self->render(
367     'bank_transactions/_template_list',
368     { output => 0 },
369     TEMPLATES_AP => $templates_ap,
370     TEMPLATES_GL => $templates_gl,
371   );
372
373   $self->render(\to_json({ html => $output }), { type => 'json', process => 0 });
374 }
375
376 sub action_ajax_add_list {
377   my ($self) = @_;
378
379   my @where_sale     = (amount => { ne => \'paid' });
380   my @where_purchase = (amount => { ne => \'paid' });
381
382   if ($::form->{invnumber}) {
383     push @where_sale,     (invnumber => { ilike => like($::form->{invnumber})});
384     push @where_purchase, (invnumber => { ilike => like($::form->{invnumber})});
385   }
386
387   if ($::form->{amount}) {
388     push @where_sale,     (amount => $::form->parse_amount(\%::myconfig, $::form->{amount}));
389     push @where_purchase, (amount => $::form->parse_amount(\%::myconfig, $::form->{amount}));
390   }
391
392   if ($::form->{vcnumber}) {
393     push @where_sale,     ('customer.customernumber' => { ilike => like($::form->{vcnumber})});
394     push @where_purchase, ('vendor.vendornumber'     => { ilike => like($::form->{vcnumber})});
395   }
396
397   if ($::form->{vcname}) {
398     push @where_sale,     ('customer.name' => { ilike => like($::form->{vcname})});
399     push @where_purchase, ('vendor.name'   => { ilike => like($::form->{vcname})});
400   }
401
402   if ($::form->{transdatefrom}) {
403     my $fromdate = $::locale->parse_date_to_object($::form->{transdatefrom});
404     if ( ref($fromdate) eq 'DateTime' ) {
405       push @where_sale,     ('transdate' => { ge => $fromdate});
406       push @where_purchase, ('transdate' => { ge => $fromdate});
407     };
408   }
409
410   if ($::form->{transdateto}) {
411     my $todate = $::locale->parse_date_to_object($::form->{transdateto});
412     if ( ref($todate) eq 'DateTime' ) {
413       $todate->add(days => 1);
414       push @where_sale,     ('transdate' => { lt => $todate});
415       push @where_purchase, ('transdate' => { lt => $todate});
416     };
417   }
418
419   my $all_open_ar_invoices = SL::DB::Manager::Invoice        ->get_all(where => \@where_sale,     with_objects => 'customer');
420   my $all_open_ap_invoices = SL::DB::Manager::PurchaseInvoice->get_all(where => \@where_purchase, with_objects => 'vendor');
421
422   my @all_open_invoices = @{ $all_open_ar_invoices };
423   # add ap invoices, filtering out subcent open amounts
424   push @all_open_invoices, grep { abs($_->amount - $_->paid) >= 0.01 } @{ $all_open_ap_invoices };
425
426   @all_open_invoices = sort { $a->id <=> $b->id } @all_open_invoices;
427
428   my $output  = $self->render(
429     'bank_transactions/add_list',
430     { output => 0 },
431     INVOICES => \@all_open_invoices,
432   );
433
434   my %result = ( count => 0, html => $output );
435
436   $self->render(\to_json(\%result), { type => 'json', process => 0 });
437 }
438
439 sub action_ajax_accept_invoices {
440   my ($self) = @_;
441
442   my @selected_invoices;
443   foreach my $invoice_id (@{ $::form->{invoice_id} || [] }) {
444     my $invoice_object = SL::DB::Manager::Invoice->find_by(id => $invoice_id) || SL::DB::Manager::PurchaseInvoice->find_by(id => $invoice_id);
445     push @selected_invoices, $invoice_object;
446   }
447
448   $self->render(
449     'bank_transactions/invoices',
450     { layout => 0 },
451     INVOICES => \@selected_invoices,
452     bt_id    => $::form->{bt_id},
453   );
454 }
455
456 sub save_invoices {
457   my ($self) = @_;
458
459   return 0 if !$::form->{invoice_ids};
460
461   my %invoice_hash = %{ delete $::form->{invoice_ids} };  # each key (the bt line with a bt_id) contains an array of invoice_ids
462
463   # e.g. three partial payments with bt_ids 54, 55 and 56 for invoice with id 74:
464   # $invoice_hash = {
465   #         '55' => [
466   #                 '74'
467   #               ],
468   #         '54' => [
469   #                 '74'
470   #               ],
471   #         '56' => [
472   #                 '74'
473   #               ]
474   #       };
475   #
476   # or if the payment with bt_id 44 is used to pay invoices with ids 50, 51 and 52
477   # $invoice_hash = {
478   #           '44' => [ '50', '51', 52' ]
479   #         };
480
481   $::form->{invoice_skontos} ||= {}; # hash of arrays containing the payment types, could be empty
482
483   # a bank_transaction may be assigned to several invoices, i.e. a customer
484   # might pay several open invoices with one transaction
485
486   $self->problems([]);
487
488   my $count = 0;
489
490   if ( $::form->{proposal_ids} ) {
491     foreach (@{ $::form->{proposal_ids} }) {
492       my  $bank_transaction_id = $_;
493       my  $invoice_ids = $invoice_hash{$_};
494       push @{ $self->problems }, $self->save_single_bank_transaction(
495         bank_transaction_id => $bank_transaction_id,
496         invoice_ids         => $invoice_ids,
497         sources             => ($::form->{sources} // {})->{$_},
498         memos               => ($::form->{memos}   // {})->{$_},
499       );
500       $count += scalar( @{$invoice_ids} );
501     }
502   } else {
503     while ( my ($bank_transaction_id, $invoice_ids) = each(%invoice_hash) ) {
504       push @{ $self->problems }, $self->save_single_bank_transaction(
505         bank_transaction_id => $bank_transaction_id,
506         invoice_ids         => $invoice_ids,
507         sources             => [  map { $::form->{"sources_${bank_transaction_id}_${_}"} } @{ $invoice_ids } ],
508         memos               => [  map { $::form->{"memos_${bank_transaction_id}_${_}"}   } @{ $invoice_ids } ],
509       );
510       $count += scalar( @{$invoice_ids} );
511     }
512   }
513   my $max_count = $count;
514   foreach (@{ $self->problems }) {
515     $count-- if $_->{result} eq 'error';
516   }
517   return ($count, $max_count);
518 }
519
520 sub action_save_invoices {
521   my ($self) = @_;
522   my ($success_count, $max_count) = $self->save_invoices();
523
524   if ($success_count == $max_count) {
525     flash('ok', t8('#1 invoice(s) saved.', $success_count));
526   } else {
527     flash('error', t8('At least #1 invoice(s) not saved', $max_count - $success_count));
528   }
529
530   $self->action_list();
531 }
532
533 sub action_save_proposals {
534   my ($self) = @_;
535
536   if ( $::form->{proposal_ids} ) {
537     my $propcount = scalar(@{ $::form->{proposal_ids} });
538     if ( $propcount > 0 ) {
539       my $count = $self->save_invoices();
540
541       flash('ok', t8('#1 proposal(s) with #2 invoice(s) saved.',  $propcount, $count));
542     }
543   }
544   $self->action_list();
545
546 }
547
548 sub save_single_bank_transaction {
549   my ($self, %params) = @_;
550
551   my %data = (
552     %params,
553     bank_transaction => SL::DB::Manager::BankTransaction->find_by(id => $params{bank_transaction_id}),
554     invoices         => [],
555   );
556
557   if (!$data{bank_transaction}) {
558     return {
559       %data,
560       result => 'error',
561       message => $::locale->text('The ID #1 is not a valid database ID.', $data{bank_transaction_id}),
562     };
563   }
564
565   my $bank_transaction = $data{bank_transaction};
566
567   if ($bank_transaction->closed_period) {
568     return {
569       %data,
570       result => 'error',
571       message => $::locale->text('Cannot post payment for a closed period!'),
572     };
573   }
574   my (@warnings);
575
576   my $worker = sub {
577     my $bt_id                 = $data{bank_transaction_id};
578     my $sign                  = $bank_transaction->amount < 0 ? -1 : 1;
579     my $payment_received      = $bank_transaction->amount > 0;
580     my $payment_sent          = $bank_transaction->amount < 0;
581
582
583     foreach my $invoice_id (@{ $params{invoice_ids} }) {
584       my $invoice = SL::DB::Manager::Invoice->find_by(id => $invoice_id) || SL::DB::Manager::PurchaseInvoice->find_by(id => $invoice_id);
585       if (!$invoice) {
586         return {
587           %data,
588           result  => 'error',
589           message => $::locale->text("The ID #1 is not a valid database ID.", $invoice_id),
590         };
591       }
592       push @{ $data{invoices} }, $invoice;
593     }
594
595     if (   $payment_received
596         && any {    ( $_->is_sales && ($_->amount < 0))
597                  || (!$_->is_sales && ($_->amount > 0))
598                } @{ $data{invoices} }) {
599       return {
600         %data,
601         result  => 'error',
602         message => $::locale->text("Received payments can only be posted for sales invoices and purchase credit notes."),
603       };
604     }
605
606     if (   $payment_sent
607         && any {    ( $_->is_sales && ($_->amount > 0))
608                  || (!$_->is_sales && ($_->amount < 0) && ($_->invoice_type eq 'purchase_invoice'))
609                } @{ $data{invoices} }) {
610       return {
611         %data,
612         result  => 'error',
613         message => $::locale->text("Sent payments can only be posted for purchase invoices and sales credit notes."),
614       };
615     }
616
617     my $max_invoices = scalar(@{ $data{invoices} });
618     my $n_invoices   = 0;
619
620     foreach my $invoice (@{ $data{invoices} }) {
621       my $source = ($data{sources} // [])->[$n_invoices];
622       my $memo   = ($data{memos}   // [])->[$n_invoices];
623
624       $n_invoices++ ;
625       # safety check invoice open
626       croak("Invoice closed. Cannot proceed.") unless ($invoice->open_amount);
627
628       if (   ($payment_sent     && $bank_transaction->not_assigned_amount >= 0)
629           || ($payment_received && $bank_transaction->not_assigned_amount <= 0)) {
630         return {
631           %data,
632           result  => 'error',
633           message => $::locale->text("A payment can only be posted for multiple invoices if the amount to post is equal to or bigger than the sum of the open amounts of the affected invoices."),
634         };
635       }
636
637       my ($payment_type, $free_skonto_amount);
638       if ( defined $::form->{invoice_skontos}->{"$bt_id"} ) {
639         $payment_type = shift(@{ $::form->{invoice_skontos}->{"$bt_id"} });
640       } else {
641         $payment_type = 'without_skonto';
642       }
643
644       if ($payment_type eq 'free_skonto') {
645         # parse user input > 0
646         if ($::form->parse_amount(\%::myconfig, $::form->{"free_skonto_amount"}->{"$bt_id"}{$invoice->id}) > 0) {
647           $free_skonto_amount = $::form->parse_amount(\%::myconfig, $::form->{"free_skonto_amount"}->{"$bt_id"}{$invoice->id});
648         } else {
649           return {
650             %data,
651             result  => 'error',
652             message => $::locale->text("Free skonto amount has to be a positive number."),
653           };
654         }
655       }
656     # pay invoice
657     # TODO rewrite this: really booked amount should be a return value of Payment.pm
658     # also this controller shouldnt care about how to calc skonto. we simply delegate the
659     # payment_type to the helper and get the corresponding bank_transaction values back
660     # hotfix to get the signs right - compare absolute values and later set the signs
661     # should be better done elsewhere - changing not_assigned_amount to abs feels seriously bogus
662
663     my $open_amount = $payment_type eq 'with_skonto_pt' ? $invoice->amount_less_skonto : $invoice->open_amount;
664     $open_amount            = abs($open_amount);
665     $open_amount           -= $free_skonto_amount if ($payment_type eq 'free_skonto');
666     my $not_assigned_amount = abs($bank_transaction->not_assigned_amount);
667     my $amount_for_booking  = ($open_amount < $not_assigned_amount) ? $open_amount : $not_assigned_amount;
668     my $amount_for_payment  = $amount_for_booking;
669
670     # get the right direction for the payment bookings (all amounts < 0 are stornos, credit notes or negative ap)
671     $amount_for_payment *= -1 if $invoice->amount < 0;
672     $free_skonto_amount *= -1 if ($free_skonto_amount && $invoice->amount < 0);
673     # get the right direction for the bank transaction
674     $amount_for_booking *= $sign;
675
676     $bank_transaction->invoice_amount($bank_transaction->invoice_amount + $amount_for_booking);
677
678     # ... and then pay the invoice
679     my @acc_ids = $invoice->pay_invoice(chart_id => $bank_transaction->local_bank_account->chart_id,
680                           trans_id      => $invoice->id,
681                           amount        => $amount_for_payment,
682                           payment_type  => $payment_type,
683                           source        => $source,
684                           memo          => $memo,
685                           skonto_amount => $free_skonto_amount,
686                           transdate     => $bank_transaction->valutadate->to_kivitendo);
687     # ... and record the origin via BankTransactionAccTrans
688     if (scalar(@acc_ids) < 2) {
689       return {
690         %data,
691         result  => 'error',
692         message => $::locale->text("Unable to book transactions for bank purpose #1", $bank_transaction->purpose),
693       };
694     }
695     foreach my $acc_trans_id (@acc_ids) {
696         my $id_type = $invoice->is_sales ? 'ar' : 'ap';
697         my  %props_acc = (
698           acc_trans_id        => $acc_trans_id,
699           bank_transaction_id => $bank_transaction->id,
700           $id_type            => $invoice->id,
701         );
702         SL::DB::BankTransactionAccTrans->new(%props_acc)->save;
703     }
704       # Record a record link from the bank transaction to the invoice
705       my %props = (
706         from_table => 'bank_transactions',
707         from_id    => $bt_id,
708         to_table   => $invoice->is_sales ? 'ar' : 'ap',
709         to_id      => $invoice->id,
710       );
711       SL::DB::RecordLink->new(%props)->save;
712
713       # "close" a sepa_export_item if it exists
714       # code duplicated in action_save_proposals!
715       # currently only works, if there is only exactly one open sepa_export_item
716       if ( my $seis = $invoice->find_sepa_export_items({ executed => 0 }) ) {
717         if ( scalar @$seis == 1 ) {
718           # moved the execution and the check for sepa_export into a method,
719           # this isn't part of a transaction, though
720           $seis->[0]->set_executed if $invoice->id == $seis->[0]->arap_id;
721         }
722       }
723
724     }
725     $bank_transaction->save;
726
727     # 'undef' means 'no error' here.
728     return undef;
729   };
730
731   my $error;
732   my $rez = $data{bank_transaction}->db->with_transaction(sub {
733     eval {
734       $error = $worker->();
735       1;
736
737     } or do {
738       $error = {
739         %data,
740         result  => 'error',
741         message => $@,
742       };
743     };
744
745     # Rollback Fehler nicht weiterreichen
746     # die if $error;
747     # aber einen rollback von hand
748     $::lxdebug->message(LXDebug->DEBUG2(),"finish worker with ". ($error ? $error->{result} : '-'));
749     $data{bank_transaction}->db->dbh->rollback if $error && $error->{result} eq 'error';
750   });
751
752   return grep { $_ } ($error, @warnings);
753 }
754 sub action_unlink_bank_transaction {
755   my ($self, %params) = @_;
756
757   croak("No bank transaction ids") unless scalar @{ $::form->{ids}} > 0;
758
759   my $success_count;
760
761   foreach my $bt_id (@{ $::form->{ids}} )  {
762
763     my $bank_transaction = SL::DB::Manager::BankTransaction->find_by(id => $bt_id);
764     croak("No valid bank transaction found") unless (ref($bank_transaction)  eq 'SL::DB::BankTransaction');
765     croak t8('Cannot unlink payment for a closed period!') if $bank_transaction->closed_period;
766
767     # everything in one transaction
768     my $rez = $bank_transaction->db->with_transaction(sub {
769       # 1. remove all reconciliations (due to underlying trigger, this has to be the first step)
770       my $rec_links = SL::DB::Manager::ReconciliationLink->get_all(where => [ bank_transaction_id => $bt_id ]);
771       $_->delete for @{ $rec_links };
772
773       my %trans_ids;
774       foreach my $acc_trans_id_entry (@{ SL::DB::Manager::BankTransactionAccTrans->get_all(where => [bank_transaction_id => $bt_id ] )}) {
775
776         my $acc_trans = SL::DB::Manager::AccTransaction->get_all(where => [acc_trans_id => $acc_trans_id_entry->acc_trans_id]);
777
778         # save trans_id and type
779         die "no type" unless ($acc_trans_id_entry->ar_id || $acc_trans_id_entry->ap_id || $acc_trans_id_entry->gl_id);
780         $trans_ids{$acc_trans_id_entry->ar_id} = 'ar' if $acc_trans_id_entry->ar_id;
781         $trans_ids{$acc_trans_id_entry->ap_id} = 'ap' if $acc_trans_id_entry->ap_id;
782         $trans_ids{$acc_trans_id_entry->gl_id} = 'gl' if $acc_trans_id_entry->gl_id;
783         # 2. all good -> ready to delete acc_trans and bt_acc link
784         $acc_trans_id_entry->delete;
785         $_->delete for @{ $acc_trans };
786       }
787       # 3. update arap.paid (may not be 0, yet)
788       #    or in case of gl, delete whole entry
789       while (my ($trans_id, $type) = each %trans_ids) {
790         if ($type eq 'gl') {
791           SL::DB::Manager::GLTransaction->delete_all(where => [ id => $trans_id ]);
792           next;
793         }
794         die ("invalid type") unless $type =~ m/^(ar|ap)$/;
795
796         # recalc and set paid via database query
797         my $query = qq|UPDATE $type SET paid =
798                         (SELECT COALESCE(abs(sum(amount)),0) FROM acc_trans
799                          WHERE trans_id = ?
800                          AND chart_link ilike '%paid%')
801                        WHERE id = ?|;
802
803         die if (do_query($::form, $bank_transaction->db->dbh, $query, $trans_id, $trans_id) == -1);
804       }
805       # 4. and delete all (if any) record links
806       my $rl = SL::DB::Manager::RecordLink->delete_all(where => [ from_id => $bt_id, from_table => 'bank_transactions' ]);
807
808       # 5. finally reset  this bank transaction
809       $bank_transaction->invoice_amount(0);
810       $bank_transaction->cleared(0);
811       $bank_transaction->save;
812       # 6. and add a log entry in history_erp
813       SL::DB::History->new(
814         trans_id    => $bank_transaction->id,
815         snumbers    => 'bank_transaction_unlink_' . $bank_transaction->id,
816         employee_id => SL::DB::Manager::Employee->current->id,
817         what_done   => 'bank_transaction',
818         addition    => 'UNLINKED',
819       )->save();
820
821       1;
822
823     }) || die t8('error while unlinking payment #1 : ', $bank_transaction->purpose) . $bank_transaction->db->error . "\n";
824
825     $success_count++;
826   }
827
828   flash('ok', t8('#1 bank transaction bookings undone.', $success_count));
829   $self->action_list_all() unless $params{testcase};
830 }
831 #
832 # filters
833 #
834
835 sub check_auth {
836   $::auth->assert('bank_transaction');
837 }
838
839 #
840 # helpers
841 #
842
843 sub make_filter_summary {
844   my ($self) = @_;
845
846   my $filter = $::form->{filter} || {};
847   my @filter_strings;
848
849   my @filters = (
850     [ $filter->{"transdate:date::ge"},      $::locale->text('Transdate')  . " " . $::locale->text('From Date') ],
851     [ $filter->{"transdate:date::le"},      $::locale->text('Transdate')  . " " . $::locale->text('To Date')   ],
852     [ $filter->{"valutadate:date::ge"},     $::locale->text('Valutadate') . " " . $::locale->text('From Date') ],
853     [ $filter->{"valutadate:date::le"},     $::locale->text('Valutadate') . " " . $::locale->text('To Date')   ],
854     [ $filter->{"amount:number"},           $::locale->text('Amount')                                          ],
855     [ $filter->{"bank_account_id:integer"}, $::locale->text('Local bank account')                              ],
856   );
857
858   for (@filters) {
859     push @filter_strings, "$_->[1]: $_->[0]" if $_->[0];
860   }
861
862   $self->{filter_summary} = join ', ', @filter_strings;
863 }
864
865 sub prepare_report {
866   my ($self)      = @_;
867
868   my $callback    = $self->models->get_callback;
869
870   my $report      = SL::ReportGenerator->new(\%::myconfig, $::form);
871   $self->{report} = $report;
872
873   my @columns     = qw(ids local_bank_name transdate valudate remote_name remote_account_number remote_bank_code amount invoice_amount invoices currency purpose local_account_number local_bank_code id);
874   my @sortable    = qw(local_bank_name transdate valudate remote_name remote_account_number remote_bank_code amount                                  purpose local_account_number local_bank_code);
875
876   my %column_defs = (
877     ids                 => { raw_header_data => checkbox_tag("", id => "check_all", checkall  => "[data-checkall=1]"),
878                              'align'         => 'center',
879                              raw_data        => sub { if (@{ $_[0]->linked_invoices }) {
880                                                         if ($_[0]->closed_period) {
881                                                           html_tag('text', "X"); #, tooltip => t8('Bank Transaction is in a closed period.')),
882                                                         } else {
883                                                           checkbox_tag("ids[]", value => $_[0]->id, "data-checkall" => 1);
884                                                         }
885                                                 } } },
886     transdate             => { sub   => sub { $_[0]->transdate_as_date } },
887     valutadate            => { sub   => sub { $_[0]->valutadate_as_date } },
888     remote_name           => { },
889     remote_account_number => { },
890     remote_bank_code      => { },
891     amount                => { sub   => sub { $_[0]->amount_as_number },
892                                align => 'right' },
893     invoice_amount        => { sub   => sub { $_[0]->invoice_amount_as_number },
894                                align => 'right' },
895     invoices              => { sub   => sub { my @invnumbers; for my $obj (@{ $_[0]->linked_invoices }) {
896                                                                 next unless $obj; push @invnumbers, $obj->invnumber } return \@invnumbers } },
897     currency              => { sub   => sub { $_[0]->currency->name } },
898     purpose               => { },
899     local_account_number  => { sub   => sub { $_[0]->local_bank_account->account_number } },
900     local_bank_code       => { sub   => sub { $_[0]->local_bank_account->bank_code } },
901     local_bank_name       => { sub   => sub { $_[0]->local_bank_account->name } },
902     id                    => {},
903   );
904
905   map { $column_defs{$_}->{text} ||= $::locale->text( $self->models->get_sort_spec->{$_}->{title} ) } keys %column_defs;
906
907   $report->set_options(
908     std_column_visibility => 1,
909     controller_class      => 'BankTransaction',
910     output_format         => 'HTML',
911     top_info_text         => $::locale->text('Bank transactions'),
912     title                 => $::locale->text('Bank transactions'),
913     allow_pdf_export      => 1,
914     allow_csv_export      => 1,
915   );
916   $report->set_columns(%column_defs);
917   $report->set_column_order(@columns);
918   $report->set_export_options(qw(list_all filter));
919   $report->set_options_from_form;
920   $self->models->disable_plugin('paginated') if $report->{options}{output_format} =~ /^(pdf|csv)$/i;
921   $self->models->set_report_generator_sort_options(report => $report, sortable_columns => \@sortable);
922
923   my $bank_accounts = SL::DB::Manager::BankAccount->get_all_sorted();
924
925   $report->set_options(
926     raw_top_info_text     => $self->render('bank_transactions/report_top',    { output => 0 }, BANK_ACCOUNTS => $bank_accounts),
927     raw_bottom_info_text  => $self->render('bank_transactions/report_bottom', { output => 0 }),
928   );
929 }
930
931 sub init_problems { [] }
932
933 sub init_models {
934   my ($self) = @_;
935
936   SL::Controller::Helper::GetModels->new(
937     controller => $self,
938     sorted     => {
939       _default => {
940         by  => 'transdate',
941         dir => 0,   # 1 = ASC, 0 = DESC : default sort is newest at top
942       },
943       id                    => t8('ID'),
944       transdate             => t8('Transdate'),
945       remote_name           => t8('Remote name'),
946       amount                => t8('Amount'),
947       invoice_amount        => t8('Assigned'),
948       invoices              => t8('Linked invoices'),
949       valutadate            => t8('Valutadate'),
950       remote_account_number => t8('Remote account number'),
951       remote_bank_code      => t8('Remote bank code'),
952       currency              => t8('Currency'),
953       purpose               => t8('Purpose'),
954       local_account_number  => t8('Local account number'),
955       local_bank_code       => t8('Local bank code'),
956       local_bank_name       => t8('Bank account'),
957     },
958     with_objects => [ 'local_bank_account', 'currency' ],
959   );
960 }
961
962 sub load_ap_record_template_url {
963   my ($self, $template) = @_;
964
965   return $self->url_for(
966     controller                           => 'ap.pl',
967     action                               => 'load_record_template',
968     id                                   => $template->id,
969     'form_defaults.amount_1'             => $::form->format_amount(\%::myconfig, -1 * $self->transaction->amount, 2),
970     'form_defaults.transdate'            => $self->transaction->transdate_as_date,
971     'form_defaults.duedate'              => $self->transaction->transdate_as_date,
972     'form_defaults.no_payment_bookings'  => 1,
973     'form_defaults.paid_1_suggestion'    => $::form->format_amount(\%::myconfig, -1 * $self->transaction->amount, 2),
974     'form_defaults.AP_paid_1_suggestion' => $self->transaction->local_bank_account->chart->accno,
975     'form_defaults.callback'             => $self->callback,
976   );
977 }
978
979 sub load_gl_record_template_url {
980   my ($self, $template) = @_;
981
982   return $self->url_for(
983     controller                           => 'gl.pl',
984     action                               => 'load_record_template',
985     id                                   => $template->id,
986     'form_defaults.amount_1'             => abs($self->transaction->not_assigned_amount), # always positive
987     'form_defaults.transdate'            => $self->transaction->transdate_as_date,
988     'form_defaults.callback'             => $self->callback,
989     'form_defaults.bt_id'                => $self->transaction->id,
990     'form_defaults.bt_chart_id'          => $self->transaction->local_bank_account->chart->id,
991     'form_defaults.description'          => $self->transaction->purpose,
992   );
993 }
994
995 sub setup_search_action_bar {
996   my ($self, %params) = @_;
997
998   for my $bar ($::request->layout->get('actionbar')) {
999     $bar->add(
1000       action => [
1001         t8('Filter'),
1002         submit    => [ '#search_form', { action => 'BankTransaction/list' } ],
1003         accesskey => 'enter',
1004       ],
1005     );
1006   }
1007 }
1008
1009 sub setup_list_all_action_bar {
1010   my ($self, %params) = @_;
1011
1012   for my $bar ($::request->layout->get('actionbar')) {
1013     $bar->add(
1014       combobox => [
1015         action => [ t8('Actions') ],
1016         action => [
1017           t8('Unlink bank transactions'),
1018             submit => [ '#form', { action => 'BankTransaction/unlink_bank_transaction' } ],
1019             checks => [ [ 'kivi.check_if_entries_selected', '[name="ids[]"]' ] ],
1020             disabled  => $::instance_conf->get_payments_changeable ? t8('Cannot safely unlink bank transactions, please set the posting configuration for payments to unchangeable.') : undef,
1021           ],
1022         ],
1023         action => [
1024           t8('Filter'),
1025           submit    => [ '#filter_form', { action => 'BankTransaction/list_all' } ],
1026         accesskey => 'enter',
1027       ],
1028     );
1029   }
1030 }
1031
1032 1;
1033 __END__
1034
1035 =pod
1036
1037 =encoding utf8
1038
1039 =head1 NAME
1040
1041 SL::Controller::BankTransaction - Posting payments to invoices from
1042 bank transactions imported earlier
1043
1044 =head1 FUNCTIONS
1045
1046 =over 4
1047
1048 =item C<save_single_bank_transaction %params>
1049
1050 Takes a bank transaction ID (as parameter C<bank_transaction_id> and
1051 tries to post its amount to a certain number of invoices (parameter
1052 C<invoice_ids>, an array ref of database IDs to purchase or sales
1053 invoice objects).
1054
1055 This method handles already partly assigned bank transactions.
1056
1057 This method cannot handle already partly assigned bank transactions, i.e.
1058 a bank transaction that has a invoice_amount <> 0 but not the fully
1059 transaction amount (invoice_amount == amount).
1060
1061 If the amount of the bank transaction is higher than the sum of
1062 the assigned invoices (1 .. n) the bank transaction will only be
1063 partly assigned.
1064
1065 The whole function is wrapped in a database transaction. If an
1066 exception occurs the bank transaction is not posted at all. The same
1067 is true if the code detects an error during the execution, e.g. a bank
1068 transaction that's already been posted earlier. In both cases the
1069 database transaction will be rolled back.
1070
1071 If warnings but not errors occur the database transaction is still
1072 committed.
1073
1074 The return value is an error object or C<undef> if the function
1075 succeeded. The calling function will collect all warnings and errors
1076 and display them in a nicely formatted table if any occurred.
1077
1078 An error object is a hash reference containing the following members:
1079
1080 =over 2
1081
1082 =item * C<result> — can be either C<warning> or C<error>. Warnings are
1083 displayed slightly different than errors.
1084
1085 =item * C<message> — a human-readable message included in the list of
1086 errors meant as the description of why the problem happened
1087
1088 =item * C<bank_transaction_id>, C<invoice_ids> — the same parameters
1089 that the function was called with
1090
1091 =item * C<bank_transaction> — the database object
1092 (C<SL::DB::BankTransaction>) corresponding to C<bank_transaction_id>
1093
1094 =item * C<invoices> — an array ref of the database objects (either
1095 C<SL::DB::Invoice> or C<SL::DB::PurchaseInvoice>) corresponding to
1096 C<invoice_ids>
1097
1098 =back
1099
1100 =item C<action_unlink_bank_transaction>
1101
1102 Takes one or more bank transaction ID (as parameter C<form::ids>) and
1103 tries to revert all payment bookings including already cleared bookings.
1104
1105 This method won't undo payments that are in a closed period and assumes
1106 that payments are not manually changed, i.e. only imported payments.
1107
1108 GL-records will be deleted completely if a bank transaction was the source.
1109
1110 TODO: we still rely on linked_records for the check boxes
1111
1112 =back
1113
1114 =head1 AUTHOR
1115
1116 Niclas Zimmermann E<lt>niclas@kivitendo-premium.deE<gt>,
1117 Geoffrey Richardson E<lt>information@richardson-bueren.deE<gt>
1118
1119 =cut