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