Form::read_logo gibt es in dieser Version nicht
[kivitendo-erp.git] / SL / Controller / Reconciliation.pm
1 package SL::Controller::Reconciliation;
2
3 use strict;
4
5 use parent qw(SL::Controller::Base);
6
7 use SL::Locale::String;
8 use SL::JSON;
9 use SL::Controller::Helper::ParseFilter;
10 use SL::Helper::Flash;
11
12 use SL::DB::BankTransaction;
13 use SL::DB::Manager::BankAccount;
14 use SL::DB::AccTransaction;
15 use SL::DB::ReconciliationLink;
16 use List::Util qw(sum);
17
18 use Rose::Object::MakeMethods::Generic (
19   'scalar --get_set_init' => [ qw(cleared BANK_ACCOUNTS) ],
20 );
21
22 __PACKAGE__->run_before('check_auth');
23 __PACKAGE__->run_before('_bank_account');
24
25 #
26 # actions
27 #
28
29 sub action_search {
30   my ($self) = @_;
31
32   $self->setup_search_action_bar;
33   $self->render('reconciliation/search');
34 }
35
36 sub action_reconciliation {
37   my ($self) = @_;
38
39   $self->_get_proposals;
40
41   $self->_get_linked_transactions;
42
43   $self->_get_balances;
44
45   $self->setup_reconciliation_action_bar;
46   $self->render('reconciliation/form',
47                 ui_tab => scalar(@{$self->{PROPOSALS}}) > 0?1:0,
48                 title => t8('Reconciliation'));
49 }
50
51 sub action_load_overview {
52   my ($self) = @_;
53
54   $self->_get_proposals;
55
56   $self->_get_linked_transactions;
57
58   $self->_get_balances;
59
60   my $output = $self->render('reconciliation/tabs/overview', { output => 0 });
61   my %result = ( html => $output );
62
63   $self->render(\to_json(\%result), { type => 'json', process => 0 });
64 }
65
66 sub action_filter_overview {
67   my ($self) = @_;
68
69   $self->_get_linked_transactions;
70   $self->_get_balances;
71
72   my $output = $self->render('reconciliation/_linked_transactions', { output => 0 });
73   my %result = ( html               => $output,
74                  absolut_bt_balance => $::form->format_amount(\%::myconfig,      $self->{absolut_bt_balance}, 2),
75                  absolut_bb_balance => $::form->format_amount(\%::myconfig, -1 * $self->{absolut_bb_balance}, 2),
76                  bt_balance         => $::form->format_amount(\%::myconfig,      $self->{bt_balance}, 2),
77                  bb_balance         => $::form->format_amount(\%::myconfig, -1 * $self->{bb_balance}, 2)
78                  );
79
80   $self->render(\to_json(\%result), { type => 'json', process => 0 });
81 }
82
83 sub action_update_reconciliation_table {
84   my ($self) = @_;
85
86   my @errors = $self->_get_elements_and_validate();
87
88   my $output = $self->render('reconciliation/assigning_table', { output => 0 },
89                  bt_sum => $::form->format_amount(\%::myconfig, $self->{bt_sum}, 2),
90                  bb_sum => $::form->format_amount(\%::myconfig, -1 * $self->{bb_sum}, 2),
91                  errors => @errors,
92                  );
93
94   my %result = ( html => $output );
95
96   $self->render(\to_json(\%result), { type => 'json', process => 0 });
97 }
98
99 sub action_reconcile {
100   my ($self) = @_;
101
102   #Check elements
103   my @errors = $self->_get_elements_and_validate;
104
105   if (@errors) {
106     unshift(@errors, (t8('Could not reconcile chosen elements!')));
107     flash('error', @errors);
108     $self->action_reconciliation;
109     return;
110   }
111
112   $self->_reconcile;
113
114   $self->action_reconciliation;
115 }
116
117 sub action_delete_reconciliation {
118   my ($self) = @_;
119
120   my $rec_links = SL::DB::Manager::ReconciliationLink->get_all(where => [ rec_group => $::form->{rec_group} ]);
121
122   foreach my $rec_link (@{ $rec_links }) {
123     my $bank_transaction = SL::DB::Manager::BankTransaction->find_by( id           => $rec_link->bank_transaction_id );
124     my $acc_transaction  = SL::DB::Manager::AccTransaction ->find_by( acc_trans_id => $rec_link->acc_trans_id        );
125
126     $bank_transaction->cleared('0');
127     $acc_transaction->cleared('0');
128
129     $bank_transaction->save;
130     $acc_transaction->save;
131
132     $rec_link->delete;
133   }
134
135   $self->_get_linked_transactions;
136   $self->_get_balances;
137
138   my $output = $self->render('reconciliation/_linked_transactions', { output => 0 });
139   my %result = ( html               => $output,
140                  absolut_bt_balance => $::form->format_amount(\%::myconfig,      $self ->{absolut_bt_balance}, 2),
141                  absolut_bb_balance => $::form->format_amount(\%::myconfig, -1 * $self ->{absolut_bb_balance}, 2),
142                  bt_balance         => $::form->format_amount(\%::myconfig,      $self ->{bt_balance}, 2),
143                  bb_balance         => $::form->format_amount(\%::myconfig, -1 * $self ->{bb_balance}, 2)
144                  );
145
146   $self->render(\to_json(\%result), { type => 'json', process => 0 });
147 }
148
149 sub action_load_proposals {
150   my ($self) = @_;
151
152   $self->_get_proposals;
153
154   my $output = $self->render('reconciliation/tabs/automatic', { output => 0 });
155   my %result = ( html => $output );
156
157   $self->render(\to_json(\%result), { type => 'json', process => 0 });
158 }
159
160 sub action_filter_proposals {
161   my ($self) = @_;
162
163   $self->_get_balances;
164   $self->_get_proposals;
165
166   my $output = $self->render('reconciliation/proposals', { output => 0 });
167   my %result = ( html               => $output,
168                  absolut_bt_balance => $::form->format_amount(\%::myconfig,      $self ->{absolut_bt_balance}, 2),
169                  absolut_bb_balance => $::form->format_amount(\%::myconfig, -1 * $self ->{absolut_bb_balance}, 2),
170                  bt_balance         => $::form->format_amount(\%::myconfig,      $self ->{bt_balance}, 2),
171                  bb_balance         => $::form->format_amount(\%::myconfig, -1 * $self ->{bb_balance}, 2)
172                  );
173
174   $self->render(\to_json(\%result), { type => 'json', process => 0 });
175 }
176
177 sub action_reconcile_proposals {
178   my ($self) = @_;
179
180   my $counter = 0;
181
182   foreach my $bt_id ( @{ $::form->{bt_ids} }) {
183     my $rec_group = SL::DB::Manager::ReconciliationLink->get_new_rec_group();
184     my $bank_transaction = SL::DB::Manager::BankTransaction->find_by(id => $bt_id);
185     $bank_transaction->cleared('1');
186     if ( $bank_transaction->isa('SL::DB::BankTransaction') ) {
187       $bank_transaction->invoice_amount($bank_transaction->amount);
188     }
189     $bank_transaction->save;
190     foreach my $acc_trans_id (@{ $::form->{proposal_list}->{$bt_id}->{BB} }) {
191       SL::DB::ReconciliationLink->new(
192         rec_group => $rec_group,
193         bank_transaction_id => $bt_id,
194         acc_trans_id => $acc_trans_id
195       )->save;
196       my $acc_trans = SL::DB::Manager::AccTransaction->find_by(acc_trans_id => $acc_trans_id);
197       $acc_trans->cleared('1');
198       $acc_trans->save;
199     }
200     $counter++;
201   }
202
203   flash('ok', t8('#1 proposal(s) saved.', $counter));
204
205   $self->action_reconciliation;
206 }
207
208 #
209 # filters
210 #
211
212 sub check_auth {
213   $::auth->assert('bank_transaction');
214 }
215
216 sub _bank_account {
217   my ($self) = @_;
218   $self->{bank_account} = SL::DB::Manager::BankAccount->find_by(id => $::form->{filter}->{"local_bank_account_id:number"});
219 }
220
221 #
222 # helpers
223 #
224
225 sub _get_proposals {
226   my ($self) = @_;
227
228   # reconciliation suggestion is based on:
229   # * record_link exists (was paid by bank transaction)
230   # or acc_trans entry exists where
231   # * amount is exactly the same
232   # * date is the same
233   # * IBAN or account number have to match exactly (cv details, no spaces)
234   # * not a gl storno
235   # * there is exactly one match for all conditions
236
237   $self->_filter_to_where;
238
239   my $bank_transactions = SL::DB::Manager::BankTransaction->get_all(where => [ @{ $self->{bt_where} }, cleared => '0' ]);
240
241   my $check_sum;
242
243   my @proposals;
244
245   foreach my $bt (@{ $bank_transactions }) {
246     $check_sum = $bt->amount;
247     my $proposal;
248     $proposal->{BT} = $bt;
249     $proposal->{BB} = [];
250
251     # first of all check if any of the bank_transactions are already linked (i.e. were paid via bank transactions)
252     my $linked_records = SL::DB::Manager::RecordLink->get_all(where => [ from_table => 'bank_transactions', from_id => $bt->id ]);
253     foreach my $linked_record (@{ $linked_records }) {
254       my $invoice;
255       if ($linked_record->to_table eq 'ar') {
256         $invoice = SL::DB::Manager::Invoice->find_by(id => $linked_record->to_id);
257         #find payments
258         my $payments = SL::DB::Manager::AccTransaction->get_all(where => [ trans_id => $invoice->id, chart_link => { like => '%AR_paid%' }, transdate => $bt->transdate ]);
259         foreach my $payment (@{ $payments }) {
260           $check_sum += $payment->amount;
261           push @{ $proposal->{BB} }, $payment;
262         }
263       }
264       if ($linked_record->to_table eq 'ap') {
265         $invoice = SL::DB::Manager::PurchaseInvoice->find_by(id => $linked_record->to_id);
266         #find payments
267         my $payments = SL::DB::Manager::AccTransaction->get_all(where => [ trans_id => $invoice->id, chart_link => { like => '%AP_paid%' }, transdate => $bt->transdate ]);
268         foreach my $payment (@{ $payments }) {
269           $check_sum += $payment->amount;
270           push @{ $proposal->{BB} }, $payment;
271         }
272       }
273     }
274
275     #add proposal if something in acc_trans was found
276     #otherwise try to find another entry in acc_trans and add it
277     # for linked_records we allow a slight difference / imprecision, for acc_trans search we don't
278     if (scalar @{ $proposal->{BB} } and abs($check_sum) <= 0.01 ) {
279       push @proposals, $proposal;
280     } elsif (!scalar @{ $proposal->{BB} }) {
281       # use account_number and iban for matching remote account number
282       # don't suggest gl stornos (ar and ap stornos shouldn't have any payments)
283
284       my @account_number_match = (
285         ( 'ar.customer.iban'           => $bt->remote_account_number ),
286         ( 'ar.customer.account_number' => $bt->remote_account_number ),
287         ( 'ap.vendor.iban'             => $bt->remote_account_number ),
288         ( 'ap.vendor.account_number'   => $bt->remote_account_number ),
289         ( 'gl.storno'                  => '0' ),
290       );
291
292       my $acc_transactions = SL::DB::Manager::AccTransaction->get_all(where => [ @{ $self->{bb_where} },
293                                                                                  amount => -1 * $bt->amount,
294                                                                                  cleared => '0',
295                                                                                  'transdate' => $bt->transdate,
296                                                                                  or => [ @account_number_match ]
297                                                                                ],
298                                                                        with_objects => [ 'ar', 'ap', 'ar.customer', 'ap.vendor', 'gl' ]);
299       if (scalar @{ $acc_transactions } == 1) {
300         push @{ $proposal->{BB} }, @{ $acc_transactions }[0];
301         push @proposals, $proposal;
302       }
303     }
304   }
305
306   $self->{PROPOSALS} = \@proposals;
307 }
308
309 sub _get_elements_and_validate {
310   my ($self) = @_;
311
312   my @errors;
313
314   if ( not defined $::form->{bt_ids} ) {
315     push @errors, t8('No bank account chosen!');
316   }
317
318   if ( not defined $::form->{bb_ids} ) {
319     push @errors, t8('No transaction on chart bank chosen!');
320   }
321
322   if (!@errors) {
323     if (scalar @{ $::form->{bt_ids} } > 1 and scalar @{ $::form->{bb_ids} } > 1) {
324       push @errors, t8('No 1:n or n:1 relation');
325     }
326   }
327
328   my @elements;
329   my ($bt_sum, $bb_sum) = (0,0);
330
331   foreach my $bt_id (@{ $::form->{bt_ids} }) {
332     my $bt = SL::DB::Manager::BankTransaction->find_by(id => $bt_id);
333     $bt->{type} = 'BT';
334     $bt_sum += $bt->amount;
335     push @elements, $bt;
336   }
337
338   foreach my $bb_id (@{ $::form->{bb_ids} }) {
339     my $bb = SL::DB::Manager::AccTransaction->find_by(acc_trans_id => $bb_id);
340     $bb->{type} = 'BB';
341     $bb->{id} = $bb->acc_trans_id;
342     $bb_sum += $bb->amount;
343     push @elements, $bb;
344   }
345
346   if ($::form->round_amount($bt_sum + $bb_sum, 2) != 0) {
347     push @errors, t8('Out of balance!');
348   }
349
350   $self->{ELEMENTS} = \@elements;
351   $self->{bt_sum} = $bt_sum;
352   $self->{bb_sum} = $bb_sum;
353
354   return @errors;
355 }
356
357 sub _reconcile {
358   my ($self) = @_;
359
360   # 1. step: set AccTrans and BankTransactions to 'cleared'
361   foreach my $element (@{ $self->{ELEMENTS} }) {
362     $element->cleared('1');
363     $element->invoice_amount($element->amount) if $element->isa('SL::DB::BankTransaction');
364     $element->save;
365   }
366
367   # 2. step: insert entry in reconciliation_links
368   my $rec_group = SL::DB::Manager::ReconciliationLink->get_new_rec_group();
369   #There is either a 1:n relation or a n:1 relation
370   if (scalar @{ $::form->{bt_ids} } == 1) {
371     my $bt_id = @{ $::form->{bt_ids} }[0];
372     foreach my $bb_id (@{ $::form->{bb_ids} }) {
373       my $rec_link = SL::DB::ReconciliationLink->new(bank_transaction_id => $bt_id,
374                                                      acc_trans_id        => $bb_id,
375                                                      rec_group           => $rec_group);
376       $rec_link->save;
377     }
378   } else {
379     my $bb_id = @{ $::form->{bb_ids} }[0];
380     foreach my $bt_id (@{ $::form->{bt_ids} }) {
381       my $rec_link = SL::DB::ReconciliationLink->new(bank_transaction_id => $bt_id,
382                                                      acc_trans_id        => $bb_id,
383                                                      rec_group           => $rec_group);
384       $rec_link->save;
385     }
386   }
387 }
388
389 sub _filter_to_where {
390   my ($self) = @_;
391
392   my %parse_filter = parse_filter($::form->{filter});
393   my %filter = @{ $parse_filter{query} };
394
395   my (@rl_where, @bt_where, @bb_where);
396   @rl_where = ('bank_transaction.local_bank_account_id' => $filter{local_bank_account_id});
397   @bt_where = (local_bank_account_id => $filter{local_bank_account_id});
398   @bb_where = (chart_id              => $self->{bank_account}->chart_id);
399
400   if ($filter{fromdate} and $filter{todate}) {
401
402     push @rl_where, (or => [ and => [ 'acc_trans.transdate'        => $filter{fromdate},
403                                       'acc_trans.transdate'        => $filter{todate}   ],
404                              and => [ 'bank_transaction.transdate' => $filter{fromdate},
405                                       'bank_transaction.transdate' => $filter{todate}   ] ] );
406
407     push @bt_where, (transdate => $filter{todate} );
408     push @bt_where, (transdate => $filter{fromdate} );
409     push @bb_where, (transdate => $filter{todate} );
410     push @bb_where, (transdate => $filter{fromdate} );
411   }
412
413   if ( $self->{bank_account}->reconciliation_starting_date ) {
414     push @bt_where, (transdate => { ge => $self->{bank_account}->reconciliation_starting_date });
415     push @bb_where, (transdate => { ge => $self->{bank_account}->reconciliation_starting_date });
416   }
417
418   # don't try to reconcile opening and closing balance transactions
419   push @bb_where, ('acc_trans.ob_transaction' => 0);
420   push @bb_where, ('acc_trans.cb_transaction' => 0);
421
422   if ($filter{fromdate} and not $filter{todate}) {
423     push @rl_where, (or => [ 'acc_trans.transdate'        => $filter{fromdate},
424                              'bank_transaction.transdate' => $filter{fromdate} ] );
425     push @bt_where, (transdate                    => $filter{fromdate} );
426     push @bb_where, (transdate                    => $filter{fromdate} );
427   }
428
429   if ($filter{todate} and not $filter{fromdate}) {
430     push @rl_where, ( or => [ 'acc_trans.transdate'        => $filter{todate} ,
431                               'bank_transaction.transdate' => $filter{todate} ] );
432     push @bt_where, (transdate                    => $filter{todate} );
433     push @bb_where, (transdate                    => $filter{todate} );
434   }
435
436   if ($filter{cleared}) {
437     $filter{cleared} = $filter{cleared} eq 'FALSE' ? '0' : '1';
438     push @rl_where, ('acc_trans.cleared'        => $filter{cleared} );
439
440     push @bt_where, (cleared                    => $filter{cleared} );
441     push @bb_where, (cleared                    => $filter{cleared} );
442   }
443
444   $self->{rl_where} = \@rl_where;
445   $self->{bt_where} = \@bt_where;
446   $self->{bb_where} = \@bb_where;
447 }
448
449 sub _get_linked_transactions {
450   my ($self) = @_;
451
452   $self->_filter_to_where;
453
454   my (@where, @bt_where, @bb_where);
455   # don't try to reconcile opening and closing balances
456   # instead use an offset in configuration
457
458   @where    = (@{ $self->{rl_where} });
459   @bt_where = (@{ $self->{bt_where} }, cleared => '0');
460   @bb_where = (@{ $self->{bb_where} }, cleared => '0');
461
462   my @rows;
463
464   my $reconciliation_groups = SL::DB::Manager::ReconciliationLink->get_all(distinct => 1,
465                                                                            select => ['rec_group'],
466                                                                            where => \@where,
467                                                                            with_objects => ['bank_transaction', 'acc_trans']);
468
469   my $fromdate = $::locale->parse_date_to_object($::form->{filter}->{fromdate_date__ge});
470   my $todate   = $::locale->parse_date_to_object($::form->{filter}->{todate_date__le});
471
472   foreach my $rec_group (@{ $reconciliation_groups }) {
473     my $linked_transactions = SL::DB::Manager::ReconciliationLink->get_all(where => [rec_group => $rec_group->rec_group], with_objects => ['bank_transaction', 'acc_trans']);
474     my $line;
475     my $first_transaction = shift @{ $linked_transactions };
476     my $first_bt = $first_transaction->bank_transaction;
477     my $first_bb = $first_transaction->acc_trans;
478
479     if (defined $fromdate) {
480       $first_bt->{class} = 'out_of_balance' if ( $first_bt->transdate lt $fromdate );
481       $first_bb->{class} = 'out_of_balance' if ( $first_bb->transdate lt $fromdate );
482     }
483     if (defined $todate) {
484       $first_bt->{class} = 'out_of_balance' if ( $first_bt->transdate gt $todate );
485       $first_bb->{class} = 'out_of_balance' if ( $first_bb->transdate gt $todate );
486     }
487     $line->{BT} = [ $first_bt ];
488     $line->{BB} = [ $first_bb ];
489     $line->{rec_group} = $first_transaction->rec_group;
490     $line->{type} = 'Link';
491
492     #add the rest of transaction of this group
493     my ($previous_bt_id, $previous_acc_trans_id) = ($first_transaction->bank_transaction_id, $first_transaction->acc_trans_id);
494     foreach my $linked_transaction (@{ $linked_transactions }) {
495       my $bank_transaction = $linked_transaction->bank_transaction;
496       my $acc_transaction  = $linked_transaction->acc_trans;
497       if (defined $fromdate) {
498         $bank_transaction->{class} = 'out_of_balance' if ( $bank_transaction->transdate lt $fromdate );
499         $acc_transaction->{class}  = 'out_of_balance' if ( $acc_transaction->transdate  lt $fromdate );
500       }
501       if (defined $todate) {
502         $bank_transaction->{class} = 'out_of_balance' if ( $bank_transaction->transdate gt $todate );
503         $acc_transaction->{class}  = 'out_of_balance' if ( $acc_transaction->transdate  gt $todate );
504       }
505       if ($bank_transaction->id != $previous_bt_id) {
506         push @{ $line->{BT} }, $bank_transaction;
507       }
508       if ($acc_transaction->acc_trans_id != $previous_acc_trans_id) {
509         push @{ $line->{BB} }, $acc_transaction;
510       }
511     }
512     push @rows, $line;
513   }
514
515   # add non-cleared bank transactions
516   my $bank_transactions = SL::DB::Manager::BankTransaction->get_all(where => \@bt_where);
517   foreach my $bt (@{ $bank_transactions }) {
518     my $line;
519     $line->{BT} = [ $bt ];
520     $line->{type} = 'BT';
521     $line->{id} = $bt->id;
522     push @rows, $line;
523   }
524
525   # add non-cleared bookings on bank
526   my $bookings_on_bank = SL::DB::Manager::AccTransaction->get_all(where => \@bb_where);
527   foreach my $bb (@{ $bookings_on_bank }) {
528     if ($::form->{filter}->{show_stornos} or !$bb->record->storno) {
529       my $line;
530       $line->{BB} = [ $bb ];
531       $line->{type} = 'BB';
532       $line->{id} = $bb->acc_trans_id;
533       push @rows, $line;
534     }
535   }
536
537   #sort lines
538   @rows = sort sort_by_transdate @rows;
539
540   $self->{LINKED_TRANSACTIONS} = \@rows;
541 }
542
543 sub sort_by_transdate {
544   if ($a->{BT} and $b->{BT}) {
545     return $a->{BT}[0]->amount <=> $b->{BT}[0]->amount if $a->{BT}[0]->transdate eq $b->{BT}[0]->transdate;
546     return $a->{BT}[0]->transdate cmp $b->{BT}[0]->transdate;
547   }
548   if ($a->{BT}) {
549     return $a->{BT}[0]->amount <=> (-1 * $b->{BB}[0]->amount) if $a->{BT}[0]->transdate eq $b->{BB}[0]->transdate;
550     return $a->{BT}[0]->transdate cmp $b->{BB}[0]->transdate;
551   }
552   if ($b->{BT}) {
553     return (-1 * $a->{BB}[0]->amount) <=> $b->{BT}[0]->amount if $a->{BB}[0]->transdate eq $b->{BT}[0]->transdate;
554     return $a->{BB}[0]->transdate cmp $b->{BT}[0]->transdate;
555   }
556   return (-1 * $a->{BB}[0]->amount) <=> (-1 * $b->{BB}[0]->amount) if $a->{BB}[0]->transdate eq $b->{BB}[0]->transdate;
557   return $a->{BB}[0]->transdate cmp $b->{BB}[0]->transdate;
558 }
559
560 sub _get_balances {
561   my ($self) = @_;
562
563   $self->_filter_to_where;
564
565   my (@bt_where, @bb_where);
566   @bt_where = @{ $self->{bt_where} };
567   @bb_where = @{ $self->{bb_where} };
568
569   my @all_bt_where = (local_bank_account_id => $self->{bank_account}->id);
570   my @all_bb_where = (chart_id              => $self->{bank_account}->chart_id);
571
572   my ($bt_balance, $bb_balance) = (0,0);
573   my ($absolut_bt_balance, $absolut_bb_balance) = (0,0);
574
575   if ( $self->{bank_account}->reconciliation_starting_date ) {
576     $bt_balance         = $self->{bank_account}->reconciliation_starting_balance;
577     $bb_balance         = $self->{bank_account}->reconciliation_starting_balance * -1;
578     $absolut_bt_balance = $self->{bank_account}->reconciliation_starting_balance;
579     $absolut_bb_balance = $self->{bank_account}->reconciliation_starting_balance * -1;
580
581     push @all_bt_where, ( transdate => { gt => $self->{bank_account}->reconciliation_starting_date });
582     push @all_bb_where, ( transdate => { gt => $self->{bank_account}->reconciliation_starting_date });
583   }
584
585   my $bank_transactions = SL::DB::Manager::BankTransaction->get_all(where => \@bt_where );
586   my $payments          = SL::DB::Manager::AccTransaction ->get_all(where => \@bb_where );
587
588   # for absolute balance get all bookings until todate
589   my $todate   = $::locale->parse_date_to_object($::form->{filter}->{todate_date__le});
590   my $fromdate = $::locale->parse_date_to_object($::form->{filter}->{fromdate_date__le});
591
592   if ($todate) {
593     push @all_bt_where, (transdate => { le => $todate });
594     push @all_bb_where, (transdate => { le => $todate });
595   }
596
597   my $all_bank_transactions = SL::DB::Manager::BankTransaction->get_all(where => \@all_bt_where);
598   my $all_payments          = SL::DB::Manager::AccTransaction ->get_all(where => \@all_bb_where);
599
600   $bt_balance += sum map { $_->amount } @{ $bank_transactions };
601   $bb_balance += sum map { $_->amount if ($::form->{filter}->{show_stornos} or !$_->record->storno) } @{ $payments };
602
603   $absolut_bt_balance += sum map { $_->amount } @{ $all_bank_transactions };
604   $absolut_bb_balance += sum map { $_->amount } @{ $all_payments };
605
606
607   $self->{bt_balance}         = $bt_balance || 0;
608   $self->{bb_balance}         = $bb_balance || 0;
609   $self->{absolut_bt_balance} = $absolut_bt_balance || 0;
610   $self->{absolut_bb_balance} = $absolut_bb_balance || 0;
611
612   $self->{difference} = $bt_balance + $bb_balance;
613 }
614
615 sub init_cleared {
616   [ { title => t8("all"),       value => ''           },
617     { title => t8("cleared"),   value => 'TRUE'       },
618     { title => t8("uncleared"), value => 'FALSE'      }, ]
619 }
620
621 sub init_BANK_ACCOUNTS {
622   SL::DB::Manager::BankAccount->get_all_sorted( query => [ obsolete => 0 ] );
623 }
624
625 sub setup_search_action_bar {
626   my ($self, %params) = @_;
627
628   for my $bar ($::request->layout->get('actionbar')) {
629     $bar->add(
630       action => [
631         t8('Show'),
632         submit    => [ '#search_form', { action => 'Reconciliation/reconciliation' } ],
633         accesskey => 'enter',
634       ],
635     );
636   }
637 }
638
639 sub setup_reconciliation_action_bar {
640   my ($self, %params) = @_;
641
642   for my $bar ($::request->layout->get('actionbar')) {
643     $bar->add(
644       action => [
645         t8('Filter'),
646         call      => [ 'filter_table' ],
647         accesskey => 'enter',
648       ],
649     );
650   }
651 }
652
653 1;