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