SL/DB/Helper/Payment.pm

   1 package SL::DB::Helper::Payment;
   2
   3 use strict;
   4
   5 use parent qw(Exporter);
   6 our @EXPORT = qw(pay_invoice);
   7 our @EXPORT_OK = qw(skonto_date amount_less_skonto within_skonto_period percent_skonto reference_account reference_amount open_amount open_percent remaining_skonto_days skonto_amount check_skonto_configuration valid_skonto_amount get_payment_suggestions validate_payment_type open_sepa_transfer_amount get_payment_select_options_for_bank_transaction exchangerate forex _skonto_charts_and_tax_correction);
   8 our %EXPORT_TAGS = (
   9   "ALL" => [@EXPORT, @EXPORT_OK],
  10 );
  11
  12 require SL::DB::Chart;
  13
  14 use Carp;
  15 use Data::Dumper;
  16 use DateTime;
  17 use List::Util qw(sum);
  18
  19 use SL::DATEV qw(:CONSTANTS);
  20 use SL::DB::Exchangerate;
  21 use SL::DB::Currency;
  22 use SL::HTML::Util;
  23 use SL::Locale::String qw(t8);
  24
  25 #
  26 # Public functions not exported by default
  27 #
  28
  29 sub pay_invoice {
  30   my ($self, %params) = @_;
  31
  32   require SL::DB::Tax;
  33
  34   my $is_sales = ref($self) eq 'SL::DB::Invoice';
  35   my $mult = $is_sales ? 1 : -1;  # multiplier for getting the right sign depending on ar/ap
  36   my @new_acc_ids;
  37   my $paid_amount = 0; # the amount that will be later added to $self->paid, should be in default currency
  38
  39   # default values if not set
  40   $params{payment_type} = 'without_skonto' unless $params{payment_type};
  41   validate_payment_type($params{payment_type});
  42
  43   # check for required parameters and optional params depending on payment_type
  44   Common::check_params(\%params, qw(chart_id transdate amount));
  45   Common::check_params(\%params, qw(bt_id)) unless $params{payment_type} eq 'without_skonto';
  46
  47   # three valid cases, test logical params in depth, before proceeding ...
  48   if ( $params{'payment_type'} eq 'without_skonto' && abs($params{'amount'}) < 0) {
  49     croak "invalid amount for payment_type 'without_skonto': $params{'amount'}\n";
  50   } elsif ($params{'payment_type'} eq 'free_skonto') {
  51     # we dont like too much automagic for this payment type.
  52     # we force caller input for amount and skonto amount
  53     Common::check_params(\%params, qw(skonto_amount));
  54     # secondly we dont want to handle credit notes and purchase credit notes
  55     croak("Cannot use 'free skonto' for credit or debit notes") if ($params{amount} < 0 || $params{skonto_amount} <= 0);
  56     # both amount have to be rounded
  57     $params{skonto_amount} = _round($params{skonto_amount});
  58     $params{amount}        = _round($params{amount});
  59     # lastly skonto_amount has to be smaller or equal than the open invoice amount
  60     if ($params{skonto_amount} > _round($self->open_amount)) {
  61       croak("Skonto amount:" . $params{skonto_amount} . " higher than the payment or open invoice amount:" . $self->open_amount);
  62     }
  63   } elsif ( $params{'payment_type'} eq 'with_skonto_pt' ) {
  64     # options with_skonto_pt doesn't require the parameter
  65     # amount, but if amount is passed, make sure it matches the expected value
  66     # note: the parameter isn't used at all - amount_less_skonto will always be used
  67     # partial skonto payments are therefore impossible to book
  68     croak "amount $params{amount} doesn't match amount less skonto: " . $self->amount_less_skonto . "\n" if $params{amount} && abs($self->amount_less_skonto - $params{amount} ) > 0.0000001;
  69     croak "payment type with_skonto_pt can't be used if payments have already been made" if $self->paid != 0;
  70   }
  71
  72
  73   my $transdate_obj;
  74   if (ref($params{transdate}) eq 'DateTime') {
  75     $transdate_obj = $params{transdate};
  76   } else {
  77     $transdate_obj = $::locale->parse_date_to_object($params{transdate});
  78   };
  79   croak t8('Illegal date') unless ref $transdate_obj;
  80
  81   # check for closed period
  82   my $closedto = $::locale->parse_date_to_object($::instance_conf->get_closedto);
  83   if ( ref $closedto && $transdate_obj < $closedto ) {
  84     croak t8('Cannot post payment for a closed period!');
  85   };
  86
  87   # check for maximum number of future days
  88   if ( $::instance_conf->get_max_future_booking_interval > 0 ) {
  89     croak t8('Cannot post transaction above the maximum future booking date!') if $transdate_obj > DateTime->now->add( days => $::instance_conf->get_max_future_booking_interval );
  90   };
  91
  92   # currency is either passed or use the invoice currency if it differs from the default currency
  93   # TODO remove
  94   my ($exchangerate,$currency);
  95   if ($params{currency} || $params{currency_id}) {
  96     if ($params{currency} || $params{currency_id} ) { # currency was specified
  97       $currency = SL::DB::Manager::Currency->find_by(name => $params{currency}) || SL::DB::Manager::Currency->find_by(id => $params{currency_id});
  98     } else { # use invoice currency
  99       $currency = SL::DB::Manager::Currency->find_by(id => $self->currency_id);
 100     };
 101     die "no currency" unless $currency;
 102     if ($currency->id == $::instance_conf->get_currency_id) {
 103       $exchangerate = 1;
 104     } else {
 105       my $rate = SL::DB::Manager::Exchangerate->find_by(currency_id => $currency->id,
 106                                                         transdate   => $transdate_obj,
 107                                                        );
 108       if ($rate) {
 109         $exchangerate = $is_sales ? $rate->buy : $rate->sell;
 110       } else {
 111         die "No exchange rate for " . $transdate_obj->to_kivitendo;
 112       };
 113     };
 114   } else { # no currency param given or currency is the same as default_currency
 115     $exchangerate = 1;
 116   };
 117
 118   # absolute skonto amount for invoice, use as reference sum to see if the
 119   # calculated skontos add up
 120   # only needed for payment_term "with_skonto_pt"
 121
 122   my $skonto_amount_check = $self->skonto_amount; # variable should be zero after calculating all skonto
 123   my $total_open_amount   = $self->open_amount;
 124
 125   # account where money is paid to/from: bank account or cash
 126   my $account_bank = SL::DB::Manager::Chart->find_by(id => $params{chart_id});
 127   croak "can't find bank account with id " . $params{chart_id} unless ref $account_bank;
 128
 129   my $reference_account = $self->reference_account;
 130   croak "can't find reference account (link = AR/AP) for invoice" unless ref $reference_account;
 131
 132   my $memo   = $params{memo}   // '';
 133   my $source = $params{source} // '';
 134
 135   my $rounded_params_amount = _round( $params{amount} ); # / $exchangerate);
 136   my $fx_gain_loss_amount = 0; # for fx_gain and fx_loss
 137
 138   my $db = $self->db;
 139   $db->with_transaction(sub {
 140     my $new_acc_trans;
 141
 142     # all three payment type create 1 AR/AP booking (the paid part)
 143     # with_skonto_pt creates 1 bank booking and n skonto bookings (1 for each tax type)
 144     # and one tax correction as a gl booking
 145     # without_skonto creates 1 bank booking
 146
 147     unless ( $rounded_params_amount == 0 ) {
 148       # cases with_skonto_pt, free_skonto and without_skonto
 149
 150       # for case with_skonto_pt we need to know the corrected amount at this
 151       # stage because we don't use $params{amount} ?!
 152
 153       my $pay_amount = $rounded_params_amount;
 154       $pay_amount = $self->amount_less_skonto if $params{payment_type} eq 'with_skonto_pt';
 155
 156       # bank account and AR/AP
 157       $paid_amount += $pay_amount * $exchangerate;
 158
 159       my $amount = (-1 * $pay_amount) * $mult;
 160
 161
 162       # total amount against bank, do we already know this by now?
 163       $new_acc_trans = SL::DB::AccTransaction->new(trans_id   => $self->id,
 164                                                    chart_id   => $account_bank->id,
 165                                                    chart_link => $account_bank->link,
 166                                                    amount     => $amount,
 167                                                    transdate  => $transdate_obj,
 168                                                    source     => $source,
 169                                                    memo       => $memo,
 170                                                    project_id => $params{project_id} ? $params{project_id} : undef,
 171                                                    taxkey     => 0,
 172                                                    tax_id     => SL::DB::Manager::Tax->find_by(taxkey => 0)->id);
 173       $new_acc_trans->save;
 174
 175       push @new_acc_ids, $new_acc_trans->acc_trans_id;
 176       # deal with fxtransaction
 177       if ( $self->currency_id != $::instance_conf->get_currency_id ) {
 178         my $fxamount = _round($amount - ($amount * $exchangerate));
 179         $new_acc_trans = SL::DB::AccTransaction->new(trans_id       => $self->id,
 180                                                      chart_id       => $account_bank->id,
 181                                                      chart_link     => $account_bank->link,
 182                                                      amount         => $fxamount * -1,
 183                                                      transdate      => $transdate_obj,
 184                                                      source         => $source,
 185                                                      memo           => $memo,
 186                                                      taxkey         => 0,
 187                                                      fx_transaction => 1,
 188                                                      tax_id         => SL::DB::Manager::Tax->find_by(taxkey => 0)->id);
 189         $new_acc_trans->save;
 190         push @new_acc_ids, $new_acc_trans->acc_trans_id;
 191         # if invoice exchangerate differs from exchangerate of payment
 192         # deal with fxloss and fxamount
 193         if ($self->exchangerate and $self->exchangerate != 1 and $self->exchangerate != $exchangerate) {
 194           my $fxgain_chart = SL::DB::Manager::Chart->find_by(id => $::instance_conf->get_fxgain_accno_id) || die "Can't determine fxgain chart";
 195           my $fxloss_chart = SL::DB::Manager::Chart->find_by(id => $::instance_conf->get_fxloss_accno_id) || die "Can't determine fxloss chart";
 196           my $gain_loss_amount = _round($amount * ($exchangerate - $self->exchangerate ) * -1,2);
 197           my $gain_loss_chart = $gain_loss_amount > 0 ? $fxgain_chart : $fxloss_chart;
 198           $fx_gain_loss_amount = $gain_loss_amount;
 199
 200           $new_acc_trans = SL::DB::AccTransaction->new(trans_id       => $self->id,
 201                                                        chart_id       => $gain_loss_chart->id,
 202                                                        chart_link     => $gain_loss_chart->link,
 203                                                        amount         => $gain_loss_amount,
 204                                                        transdate      => $transdate_obj,
 205                                                        source         => $source,
 206                                                        memo           => $memo,
 207                                                        taxkey         => 0,
 208                                                        fx_transaction => 0,
 209                                                        tax_id         => SL::DB::Manager::Tax->find_by(taxkey => 0)->id);
 210           $new_acc_trans->save;
 211           push @new_acc_ids, $new_acc_trans->acc_trans_id;
 212
 213         }
 214       }
 215     }
 216     # skonto cases
 217     if ($params{payment_type} eq 'with_skonto_pt' or $params{payment_type} eq 'free_skonto' ) {
 218
 219       my $total_skonto_amount;
 220       if ( $params{payment_type} eq 'with_skonto_pt' ) {
 221         $total_skonto_amount = $self->skonto_amount;
 222       } elsif ( $params{payment_type} eq 'free_skonto') {
 223         $total_skonto_amount = $params{skonto_amount};
 224       }
 225       my @skonto_bookings = $self->_skonto_charts_and_tax_correction(amount => $total_skonto_amount, bt_id => $params{bt_id},
 226                                                                      transdate_obj => $transdate_obj, memo => $params{memo},
 227                                                                      source => $params{source});
 228       my $reference_amount = $total_skonto_amount;
 229
 230       # create an acc_trans entry for each result of $self->skonto_charts
 231       foreach my $skonto_booking ( @skonto_bookings ) {
 232         next unless $skonto_booking->{'chart_id'};
 233         next unless $skonto_booking->{'skonto_amount'} != 0;
 234         my $amount = -1 * $skonto_booking->{skonto_amount};
 235         $new_acc_trans = SL::DB::AccTransaction->new(trans_id   => $self->id,
 236                                                      chart_id   => $skonto_booking->{'chart_id'},
 237                                                      chart_link => SL::DB::Manager::Chart->find_by(id => $skonto_booking->{'chart_id'})->link,
 238                                                      amount     => $amount * $mult,
 239                                                      transdate  => $transdate_obj,
 240                                                      source     => $params{source},
 241                                                      taxkey     => 0,
 242                                                      tax_id     => SL::DB::Manager::Tax->find_by(taxkey => 0)->id);
 243
 244         # the acc_trans entries are saved individually, not added to $self and then saved all at once
 245         $new_acc_trans->save;
 246         push @new_acc_ids, $new_acc_trans->acc_trans_id;
 247
 248         $reference_amount -= abs($amount);
 249         $paid_amount      += -1 * $amount * $exchangerate;
 250         $skonto_amount_check -= $skonto_booking->{'skonto_amount'};
 251       }
 252     }
 253     my $arap_amount = 0;
 254
 255     if ( $params{payment_type} eq 'without_skonto' ) {
 256       $arap_amount = $rounded_params_amount;
 257     } elsif ( $params{payment_type} eq 'with_skonto_pt' ) {
 258       # this should be amount + sum(amount+skonto), but while we only allow
 259       # with_skonto_pt for completely unpaid invoices we just use the value
 260       # from the invoice
 261       $arap_amount = $total_open_amount;
 262     } elsif ( $params{payment_type} eq 'free_skonto' ) {
 263       # we forced positive values and forced rounding at the beginning
 264       # therefore the above comment can be safely applied for this payment type
 265       $arap_amount = $params{amount} + $params{skonto_amount};
 266     }
 267
 268     # regardless of payment_type there is always only exactly one arap booking
 269     # TODO: compare $arap_amount to running total
 270     my $arap_booking= SL::DB::AccTransaction->new(trans_id   => $self->id,
 271                                                   chart_id   => $reference_account->id,
 272                                                   chart_link => $reference_account->link,
 273                                                   amount     => _round($arap_amount * $mult * $exchangerate - $fx_gain_loss_amount),
 274                                                   transdate  => $transdate_obj,
 275                                                   source     => '', #$params{source},
 276                                                   taxkey     => 0,
 277                                                   tax_id     => SL::DB::Manager::Tax->find_by(taxkey => 0)->id);
 278     $arap_booking->save;
 279     push @new_acc_ids, $arap_booking->acc_trans_id;
 280
 281     # hook for invoice_for_advance_payment DATEV always pairs, acc_trans_id has to be higher than arap_booking ;-)
 282     if ($self->invoice_type eq 'invoice_for_advance_payment') {
 283       my $clearing_chart = SL::DB::Chart->new(id => $::instance_conf->get_advance_payment_clearing_chart_id)->load;
 284       die "No Clearing Chart for Advance Payment" unless ref $clearing_chart eq 'SL::DB::Chart';
 285
 286       # what does ptc say
 287       my %inv_calc = $self->calculate_prices_and_taxes();
 288       my @trans_ids = keys %{ $inv_calc{amounts} };
 289       die "Invalid state for advance payment more than one trans_id" if (scalar @trans_ids > 1);
 290       my $entry = delete $inv_calc{amounts}{$trans_ids[0]};
 291       my $tax;
 292       if ($entry->{tax_id}) {
 293         $tax = SL::DB::Manager::Tax->find_by(id => $entry->{tax_id}); # || die "Can't find tax with id " . $entry->{tax_id};
 294       }
 295       if ($tax and $tax->rate != 0) {
 296         my ($netamount, $taxamount);
 297         my $roundplaces = 2;
 298         # we dont have a clue about skonto, that's why we use $arap_amount as taxincluded
 299         ($netamount, $taxamount) = Form->calculate_tax($arap_amount, $tax->rate, 1, $roundplaces);
 300         # for debugging database set
 301         my $fullmatch = $netamount == $entry->{amount} ? '::netamount total true' : '';
 302         my $transfer_chart = $tax->taxkey == 2 ? SL::DB::Chart->new(id => $::instance_conf->get_advance_payment_taxable_7_id)->load
 303                           :  $tax->taxkey == 3 ? SL::DB::Chart->new(id => $::instance_conf->get_advance_payment_taxable_19_id)->load
 304                           :  undef;
 305         die "No Transfer Chart for Advance Payment" unless ref $transfer_chart eq 'SL::DB::Chart';
 306
 307         my $arap_full_booking= SL::DB::AccTransaction->new(trans_id   => $self->id,
 308                                                            chart_id   => $clearing_chart->id,
 309                                                            chart_link => $clearing_chart->link,
 310                                                            amount     => $arap_amount * -1, # full amount
 311                                                            transdate  => $transdate_obj,
 312                                                            source     => 'Automatic Tax Booking for Payment in Advance' . $fullmatch,
 313                                                            taxkey     => 0,
 314                                                            tax_id     => SL::DB::Manager::Tax->find_by(taxkey => 0)->id);
 315         $arap_full_booking->save;
 316         push @new_acc_ids, $arap_full_booking->acc_trans_id;
 317
 318         my $arap_tax_booking= SL::DB::AccTransaction->new(trans_id   => $self->id,
 319                                                           chart_id   => $transfer_chart->id,
 320                                                           chart_link => $transfer_chart->link,
 321                                                           amount     => _round($netamount), # full amount
 322                                                           transdate  => $transdate_obj,
 323                                                           source     => 'Automatic Tax Booking for Payment in Advance' . $fullmatch,
 324                                                           taxkey     => $tax->taxkey,
 325                                                           tax_id     => $tax->id);
 326         $arap_tax_booking->save;
 327         push @new_acc_ids, $arap_tax_booking->acc_trans_id;
 328
 329         my $tax_booking= SL::DB::AccTransaction->new(trans_id   => $self->id,
 330                                                      chart_id   => $tax->chart_id,
 331                                                      chart_link => $tax->chart->link,
 332                                                      amount     => _round($taxamount),
 333                                                      transdate  => $transdate_obj,
 334                                                      source     => 'Automatic Tax Booking for Payment in Advance' . $fullmatch,
 335                                                      taxkey     => 0,
 336                                                      tax_id     => SL::DB::Manager::Tax->find_by(taxkey => 0)->id);
 337
 338         $tax_booking->save;
 339         push @new_acc_ids, $tax_booking->acc_trans_id;
 340       }
 341     }
 342     $fx_gain_loss_amount *= -1 if $self->is_sales;
 343     $self->paid($self->paid + _round($paid_amount) + $fx_gain_loss_amount) if $paid_amount;
 344     $self->datepaid($transdate_obj);
 345     $self->save;
 346
 347     # make sure transactions will be reloaded the next time $self->transactions
 348     # is called, as pay_invoice saves the acc_trans objects individually rather
 349     # than adding them to the transaction relation array.
 350     $self->forget_related('transactions');
 351
 352     my $datev_check = 0;
 353     if ( $is_sales )  {
 354       if ( (  $self->invoice && $::instance_conf->get_datev_check_on_sales_invoice  ) ||
 355            ( !$self->invoice && $::instance_conf->get_datev_check_on_ar_transaction )) {
 356         $datev_check = 1;
 357       }
 358     } else {
 359       if ( (  $self->invoice && $::instance_conf->get_datev_check_on_purchase_invoice ) ||
 360            ( !$self->invoice && $::instance_conf->get_datev_check_on_ap_transaction   )) {
 361         $datev_check = 1;
 362       }
 363     }
 364
 365     if ( $datev_check ) {
 366
 367       my $datev = SL::DATEV->new(
 368         dbh        => $db->dbh,
 369         trans_id   => $self->{id},
 370       );
 371
 372       $datev->generate_datev_data;
 373
 374       if ($datev->errors) {
 375         # this exception should be caught by with_transaction, which handles the rollback
 376         die join "\n", $::locale->text('DATEV check returned errors:'), $datev->errors;
 377       }
 378     }
 379
 380     1;
 381
 382   }) || die t8('error while paying invoice #1 : ', $self->invnumber) . $db->error . "\n";
 383   return wantarray ? @new_acc_ids : 1;
 384 }
 385
 386 sub skonto_date {
 387
 388   my $self = shift;
 389
 390   return undef unless ref $self->payment_terms;
 391   return undef unless $self->payment_terms->terms_skonto > 0;
 392   return DateTime->from_object(object => $self->transdate)->add(days => $self->payment_terms->terms_skonto);
 393 };
 394
 395 sub reference_account {
 396   my $self = shift;
 397
 398   my $is_sales = ref($self) eq 'SL::DB::Invoice';
 399
 400   require SL::DB::Manager::AccTransaction;
 401
 402   my $link_filter = $is_sales ? 'AR' : 'AP';
 403
 404   my $acc_trans = SL::DB::Manager::AccTransaction->find_by(
 405      trans_id   => $self->id,
 406      SL::DB::Manager::AccTransaction->chart_link_filter("$link_filter")
 407   );
 408
 409   return undef unless ref $acc_trans;
 410
 411   my $reference_account = SL::DB::Manager::Chart->find_by(id => $acc_trans->chart_id);
 412
 413   return $reference_account;
 414 };
 415
 416 sub reference_amount {
 417   my $self = shift;
 418
 419   my $is_sales = ref($self) eq 'SL::DB::Invoice';
 420
 421   require SL::DB::Manager::AccTransaction;
 422
 423   my $link_filter = $is_sales ? 'AR' : 'AP';
 424
 425   my $acc_trans = SL::DB::Manager::AccTransaction->find_by(
 426      trans_id   => $self->id,
 427      SL::DB::Manager::AccTransaction->chart_link_filter("$link_filter")
 428   );
 429
 430   return undef unless ref $acc_trans;
 431
 432   # this should be the same as $self->amount
 433   return $acc_trans->amount;
 434 };
 435
 436
 437 sub open_amount {
 438   my $self = shift;
 439
 440   # in the future maybe calculate this from acc_trans
 441
 442   # if the difference is 0.01 Cent this may end up as 0.009999999999998
 443   # numerically, so round this value when checking for cent threshold >= 0.01
 444
 445   return ($self->amount // 0) - ($self->paid // 0);
 446 };
 447
 448 sub open_percent {
 449   my $self = shift;
 450
 451   return 0 if $self->amount == 0;
 452   my $open_percent;
 453   if ( $self->open_amount < 0 ) {
 454     # overpaid, currently treated identically
 455     $open_percent = $self->open_amount * 100 / $self->amount;
 456   } else {
 457     $open_percent = $self->open_amount * 100 / $self->amount;
 458   };
 459
 460   return _round($open_percent) || 0;
 461 };
 462
 463 sub skonto_amount {
 464   my $self = shift;
 465
 466   return $self->amount - $self->amount_less_skonto;
 467 };
 468
 469 sub remaining_skonto_days {
 470   my $self = shift;
 471
 472   return undef unless ref $self->skonto_date;
 473
 474   my $dur = DateTime::Duration->new($self->skonto_date - DateTime->today);
 475   return $dur->delta_days();
 476
 477 };
 478
 479 sub percent_skonto {
 480   my $self = shift;
 481
 482   my $percent_skonto = 0;
 483
 484   return undef unless ref $self->payment_terms;
 485   return undef unless $self->payment_terms->percent_skonto > 0;
 486   $percent_skonto = $self->payment_terms->percent_skonto;
 487
 488   return $percent_skonto;
 489 };
 490
 491 sub amount_less_skonto {
 492   # amount that has to be paid if skonto applies, always return positive rounded values
 493   # no, rare case, but credit_notes and negative ap have negative amounts
 494   # and therefore this comment may be misguiding
 495   # the result is rounded so we can directly compare it with the user input
 496   my $self = shift;
 497
 498   my $percent_skonto = $self->percent_skonto || 0;
 499
 500   return _round($self->amount - ( $self->amount * $percent_skonto) );
 501
 502 };
 503
 504 sub check_skonto_configuration {
 505   my $self = shift;
 506
 507   my $is_sales = ref($self) eq 'SL::DB::Invoice';
 508
 509   my $skonto_configured = 1; # default is assume skonto works
 510
 511   # my $transactions = $self->transactions;
 512   foreach my $transaction (@{ $self->transactions }) {
 513     # find all transactions with an AR_amount or AP_amount link
 514     my $tax = SL::DB::Manager::Tax->get_first( where => [taxkey => $transaction->taxkey, id => $transaction->tax_id ]);
 515
 516     # acc_trans entries for the taxes (chart_link == A[RP]_tax) often
 517     # have combinations of taxkey & tax_id that don't exist in
 518     # tax. Those must be skipped.
 519     next if !$tax && ($transaction->chart_link !~ m{A[RP]_amount});
 520
 521     croak "no tax for taxkey " . $transaction->{taxkey} unless ref $tax;
 522
 523     $transaction->{chartlinks} = { map { $_ => 1 } split(m/:/, $transaction->chart_link) };
 524     if ( $is_sales && $transaction->{chartlinks}->{AR_amount} ) {
 525       $skonto_configured = 0 unless $tax->skonto_sales_chart_id;
 526     } elsif ( !$is_sales && $transaction->{chartlinks}->{AP_amount}) {
 527       $skonto_configured = 0 unless $tax->skonto_purchase_chart_id;
 528     };
 529   };
 530
 531   return $skonto_configured;
 532 };
 533
 534 sub open_sepa_transfer_amount {
 535   my $self = shift;
 536
 537   my ($vc, $key, $type);
 538   if ( ref($self) eq 'SL::DB::Invoice' ) {
 539     $vc   = 'customer';
 540     $key  = 'ap_id';
 541     $type = 'ar';
 542   } else {
 543     $vc   = 'vendor';
 544     $key  = 'ap_id';
 545     $type = 'ap';
 546   };
 547
 548   my $sql = qq|SELECT SUM(sei.amount) AS amount FROM sepa_export_items sei | .
 549             qq| LEFT JOIN sepa_export se ON (sei.sepa_export_id = se.id)   | .
 550             qq| WHERE $key = ? AND NOT se.closed AND (se.vc = '$vc')       |;
 551
 552   my ($open_sepa_amount) = $self->db->dbh->selectrow_array($sql, undef, $self->id);
 553
 554   return $open_sepa_amount || 0;
 555
 556 }
 557
 558 sub _skonto_charts_and_tax_correction {
 559   my ($self, %params)   = @_;
 560   my $amount = $params{amount} || $self->skonto_amount;
 561
 562   croak "no amount passed to skonto_charts"                    unless abs(_round($amount)) >= 0.01;
 563   croak "no banktransaction.id passed to skonto_charts"        unless $params{bt_id};
 564   croak "no banktransaction.transdate passed to skonto_charts" unless ref $params{transdate_obj} eq 'DateTime';
 565
 566   $params{memo}   //= '';
 567   $params{source} //= '';
 568
 569
 570   my $is_sales = $self->is_sales;
 571   my (@skonto_charts, $inv_calc, $total_skonto_rounded);
 572
 573   $inv_calc = $self->get_tax_and_amount_by_tax_chart_id();
 574
 575   # foreach tax.chart_id || $entry->{ta..id}
 576   while (my ($tax_chart_id, $entry) = each %{ $inv_calc } ) {
 577     my $tax = SL::DB::Manager::Tax->find_by(id => $entry->{tax_id}) || die "Can't find tax with id " . $tax_chart_id;
 578     die t8('no skonto_chart configured for taxkey #1 : #2 : #3', $tax->taxkey, $tax->taxdescription , $tax->rate * 100)
 579       unless $is_sales ? ref $tax->skonto_sales_chart : ref $tax->skonto_purchase_chart;
 580
 581     # percent net amount
 582     my $transaction_net_skonto_percent = abs($entry->{netamount} / $self->amount);
 583     my $skonto_netamount_unrounded     = abs($amount * $transaction_net_skonto_percent);
 584
 585     # percent tax amount
 586     my $transaction_tax_skonto_percent = abs($entry->{tax} / $self->amount);
 587     my $skonto_taxamount_unrounded     = abs($amount * $transaction_tax_skonto_percent);
 588
 589     my $skonto_taxamount_rounded   = _round($skonto_taxamount_unrounded);
 590     my $skonto_netamount_rounded   = _round($skonto_netamount_unrounded);
 591     my $chart_id                   = $is_sales ? $tax->skonto_sales_chart->id : $tax->skonto_purchase_chart->id;
 592
 593     # entry net + tax for caller
 594     my $rec_net = {
 595       chart_id               => $chart_id,
 596       skonto_amount          => _round($skonto_netamount_unrounded + $skonto_taxamount_unrounded),
 597     };
 598     push @skonto_charts, $rec_net;
 599     $total_skonto_rounded += $rec_net->{skonto_amount};
 600
 601     # add-on: correct tax with one linked gl booking
 602
 603     # no skonto tax correction for dual tax (reverse charge) or rate = 0 or taxamount below 0.01
 604     next if ($tax->rate == 0 || $tax->reverse_charge_chart_id || $skonto_taxamount_rounded < 0.01);
 605
 606     my ($credit, $debit);
 607     $credit = SL::DB::Manager::Chart->find_by(id => $chart_id);
 608     $debit  = SL::DB::Manager::Chart->find_by(id => $tax_chart_id);
 609     croak("No such Chart ID")  unless ref $credit eq 'SL::DB::Chart' && ref $debit eq 'SL::DB::Chart';
 610     my $notes = SL::HTML::Util->strip($self->notes);
 611
 612     my $current_transaction = SL::DB::GLTransaction->new(
 613          employee_id    => $self->employee_id,
 614          transdate      => $params{transdate_obj},
 615          notes          => $params{source} . ' ' . $params{memo},
 616          description    => $notes || $self->invnumber,
 617          reference      => t8('Skonto Tax Correction for') . " " . $tax->rate * 100 . '% ' . $self->invnumber,
 618          department_id  => $self->department_id ? $self->department_id : undef,
 619          imported       => 0, # not imported
 620          taxincluded    => 0,
 621       )->add_chart_booking(
 622          chart  => $is_sales ? $debit : $credit,
 623          debit  => abs($skonto_taxamount_rounded),
 624          source => t8('Skonto Tax Correction for') . " " . $self->invnumber,
 625          memo   => $params{memo},
 626          tax_id => 0,
 627       )->add_chart_booking(
 628          chart  => $is_sales ? $credit : $debit,
 629          credit => abs($skonto_taxamount_rounded),
 630          source => t8('Skonto Tax Correction for') . " " . $self->invnumber,
 631          memo   => $params{memo},
 632          tax_id => 0,
 633       )->post;
 634
 635     # add a stable link acc_trans_id to bank_transactions.id
 636     foreach my $transaction (@{ $current_transaction->transactions }) {
 637       my %props_acc = (
 638            acc_trans_id        => $transaction->acc_trans_id,
 639            bank_transaction_id => $params{bt_id},
 640            gl                  => $current_transaction->id,
 641       );
 642       SL::DB::BankTransactionAccTrans->new(%props_acc)->save;
 643     }
 644     # Record a record link from banktransactions to gl
 645     my %props_rl = (
 646          from_table => 'bank_transactions',
 647          from_id    => $params{bt_id},
 648          to_table   => 'gl',
 649          to_id      => $current_transaction->id,
 650     );
 651     SL::DB::RecordLink->new(%props_rl)->save;
 652     # Record a record link from arap to gl
 653     # linked gl booking will appear in tab linked records
 654     # this is just a link for convenience
 655     %props_rl = (
 656          from_table => $is_sales ? 'ar' : 'ap',
 657          from_id    => $self->id,
 658          to_table   => 'gl',
 659          to_id      => $current_transaction->id,
 660     );
 661     SL::DB::RecordLink->new(%props_rl)->save;
 662
 663   }
 664   # check for rounding errors, at least for the payment chart
 665   # we ignore tax rounding errors as long as the amount (user input or calculated)
 666   # is fully assigned.
 667   # we simply alter one cent for the first skonto booking entry
 668   # should be correct for most of the cases (no invoices with mixed taxes)
 669   if (_round($total_skonto_rounded - $amount) >= 0.01) {
 670     # subtract one cent
 671     $skonto_charts[0]->{skonto_amount} -= 0.01;
 672   } elsif (_round($amount - $total_skonto_rounded) >= 0.01) {
 673     # add one cent
 674     $skonto_charts[0]->{skonto_amount} += 0.01;
 675   }
 676
 677   # return same array of skonto charts as sub skonto_charts
 678   return @skonto_charts;
 679 }
 680
 681 sub within_skonto_period {
 682   my $self = shift;
 683   my $dateref = shift || DateTime->now->truncate( to => 'day' );
 684
 685   return undef unless ref $dateref eq 'DateTime';
 686   return 0 unless $self->skonto_date;
 687
 688   # return 1 if requested date (or today) is inside skonto period
 689   # this will also return 1 if date is before the invoice date
 690   return $dateref <= $self->skonto_date;
 691 };
 692
 693 sub valid_skonto_amount {
 694   my $self = shift;
 695   my $amount = shift || 0;
 696   my $max_skonto_percent = 0.10;
 697
 698   return 0 unless $amount > 0;
 699
 700   # does this work for other currencies?
 701   return ($self->amount*$max_skonto_percent) > $amount;
 702 };
 703
 704 sub get_payment_select_options_for_bank_transaction {
 705   my ($self, $bt_id, %params) = @_;
 706
 707
 708   # CAVEAT template code expects with_skonto_pt at position 1 for visual help
 709   # due to skonto_charts, we cannot offer skonto for credit notes and neg ap
 710   my $skontoable = $self->amount > 0 ? 1 : 0;
 711   my @options;
 712   if(!$self->skonto_date) {
 713     push(@options, { payment_type => 'without_skonto', display => t8('without skonto'), selected => 1 });
 714     # wrong call to presenter or not implemented? disabled option is ignored
 715     # push(@options, { payment_type => 'with_skonto_pt', display => t8('with skonto acc. to pt'), disabled => 1 });
 716     push(@options, { payment_type => 'free_skonto', display => t8('free skonto') }) if $skontoable;
 717     return @options;
 718   }
 719   # valid skonto date, check if skonto is preferred
 720   my $bt = SL::DB::BankTransaction->new(id => $bt_id)->load;
 721   if ($self->skonto_date && $self->within_skonto_period($bt->transdate)) {
 722     push(@options, { payment_type => 'without_skonto', display => t8('without skonto') });
 723     push(@options, { payment_type => 'with_skonto_pt', display => t8('with skonto acc. to pt'), selected => 1 }) if $skontoable;
 724   } else {
 725     push(@options, { payment_type => 'without_skonto', display => t8('without skonto') , selected => 1 });
 726     push(@options, { payment_type => 'with_skonto_pt', display => t8('with skonto acc. to pt')}) if $skontoable;
 727   }
 728   push(@options, { payment_type => 'free_skonto', display => t8('free skonto') }) if $skontoable;
 729   return @options;
 730 }
 731
 732 sub exchangerate {
 733   my ($self) = @_;
 734
 735   return 1 if $self->currency_id == $::instance_conf->get_currency_id;
 736
 737   die "transdate isn't a DateTime object:" . ref($self->transdate) unless ref($self->transdate) eq 'DateTime';
 738   my $rate = SL::DB::Manager::Exchangerate->find_by(currency_id => $self->currency_id,
 739                                                     transdate   => $self->transdate,
 740                                                    );
 741   return undef unless $rate;
 742
 743   return $self->is_sales ? $rate->buy : $rate->sell; # also undef if not defined
 744 };
 745
 746 sub get_payment_suggestions {
 747
 748   my ($self, %params) = @_;
 749
 750   my $open_amount = $self->open_amount;
 751   $open_amount   -= $self->open_sepa_transfer_amount if $params{sepa};
 752
 753   $self->{invoice_amount_suggestion} = $open_amount;
 754   undef $self->{payment_select_options};
 755   push(@{$self->{payment_select_options}} , { payment_type => 'without_skonto',  display => t8('without skonto') });
 756   if ( $self->within_skonto_period ) {
 757     # If there have been no payments yet suggest amount_less_skonto, otherwise the open amount
 758     if ( $open_amount &&                   # invoice amount not 0
 759          $open_amount == $self->amount &&  # no payments yet, or sum of payments and sepa export amounts is zero
 760          $self->check_skonto_configuration) {
 761       $self->{invoice_amount_suggestion} = $self->amount_less_skonto;
 762       push(@{$self->{payment_select_options}} , { payment_type => 'with_skonto_pt',  display => t8('with skonto acc. to pt') , selected => 1 });
 763     } else {
 764       if ( ( $self->valid_skonto_amount($self->open_amount) || $self->valid_skonto_amount($open_amount) ) and not $params{sepa} ) {
 765         # Will never be reached
 766         die "This case is as dead as the dead cat. Go to start, don't pick 2,000 \$";
 767         $self->{invoice_amount_suggestion} = $open_amount;
 768         # only suggest difference_as_skonto if open_amount exactly matches skonto_amount
 769         # AND we aren't in SEPA mode
 770         my $selected = 0;
 771         $selected = 1 if _round($open_amount) == _round($self->skonto_amount);
 772         push(@{$self->{payment_select_options}} , { payment_type => 'difference_as_skonto',  display => t8('difference as skonto') , selected => $selected });
 773       };
 774     };
 775   } else {
 776     # invoice was configured with skonto, but skonto date has passed, or no skonto available
 777     $self->{invoice_amount_suggestion} = $open_amount;
 778     # difference_as_skonto doesn't make any sense for SEPA transfer, as this doesn't cause any actual payment
 779     if ( $self->valid_skonto_amount($self->open_amount) && not $params{sepa} ) {
 780       # probably also dead code
 781       die "This case is as dead as the dead cat. Go to start, don't pick 2,000 \$";
 782       push(@{$self->{payment_select_options}} , { payment_type => 'difference_as_skonto',  display => t8('difference as skonto') , selected => 0 });
 783     };
 784   };
 785   return 1;
 786 };
 787
 788 # locales for payment type
 789 #
 790 # $main::locale->text('without_skonto')
 791 # $main::locale->text('with_skonto_pt')
 792 #
 793
 794 sub validate_payment_type {
 795   my $payment_type = shift;
 796
 797   my %allowed_payment_types = map { $_ => 1 } qw(without_skonto with_skonto_pt free_skonto);
 798   croak "illegal payment type: $payment_type, must be one of: " . join(' ', keys %allowed_payment_types) unless $allowed_payment_types{ $payment_type };
 799
 800   return 1;
 801 }
 802
 803 sub forex {
 804   my ($self) = @_;
 805   $self->currency_id == $::instance_conf->get_currency_id ? return 0 : return 1;
 806 };
 807
 808 sub _round {
 809   my $value = shift;
 810   my $num_dec = 2;
 811   return $::form->round_amount($value, 2);
 812 }
 813
 814 1;
 815
 816 __END__
 817
 818 =pod
 819
 820 =head1 NAME
 821
 822 SL::DB::Helper::Payment  Mixin providing helper methods for paying C<Invoice>
 823                          and C<PurchaseInvoice> objects and using skonto
 824
 825 =head1 SYNOPSIS
 826
 827 In addition to actually causing a payment via pay_invoice this helper contains
 828 many methods that help in determining information about the status of the
 829 invoice, such as the remaining open amount, whether skonto applies, until which
 830 date skonto applies, the skonto amount and relative percentages, what to do
 831 with skonto, ...
 832
 833 To prevent duplicate code this was all added in this mixin rather than directly
 834 in SL::DB::Invoice and SL::DB::PurchaseInvoice.
 835
 836 =over 4
 837
 838 =item C<pay_invoice %params>
 839
 840 Create a payment booking for an existing invoice object (type ar/ap/is/ir) via
 841 a configured bank account.
 842
 843 This function deals with all the acc_trans entries and also updates paid and datepaid.
 844 The params C<transdate>, C<amount> and C<chart_id> are mandantory.
 845
 846 For all valid skonto types ('free_skonto' or 'with_skonto_pt') the source of
 847 the bank_transaction is needed, therefore pay_invoice expects the param
 848 C<bt_id> with a valid bank_transactions.id.
 849
 850 If the payment type ('free_skonto') is used the number param skonto_amount is
 851 as well mandantory and needs to be positive. Furthermore the skonto amount has
 852 to be lower or equal than the open invoice amount.
 853 Payments with only skonto and zero bank transaction amount are possible.
 854
 855 Transdate can either be a date object or a date string.
 856 Chart_id is the id of the payment booking chart.
 857 Amount is either a positive or negative number, and for the case 'free_skonto' might be zero.
 858
 859 CAVEAT! The helper tries to get the sign right and all calls from BankTransaction are
 860 positive (abs($value)) values.
 861
 862
 863 Example:
 864
 865   my $ap   = SL::DB::Manager::PurchaseInvoice->find_by( invnumber => '1');
 866   my $bank = SL::DB::Manager::BankAccount->find_by( name => 'Bank');
 867   $ap->pay_invoice(chart_id      => $bank->chart_id,
 868                    amount        => $ap->open_amount,
 869                    transdate     => DateTime->now->to_kivitendo,
 870                    memo          => 'foobar',
 871                    source        => 'barfoo',
 872                    payment_type  => 'without_skonto',  # default if not specified
 873                    project_id    => 25,
 874                   );
 875
 876 or with skonto:
 877   $ap->pay_invoice(chart_id      => $bank->chart_id,
 878                    amount        => $ap->amount,       # doesn't need to be specified
 879                    transdate     => DateTime->now->to_kivitendo,
 880                    memo          => 'foobar',
 881                    source        => 'barfoo',
 882                    payment_type  => 'with_skonto',
 883                   );
 884
 885 or in a certain currency:
 886   $ap->pay_invoice(chart_id      => $bank->chart_id,
 887                    amount        => 500,
 888                    currency      => 'USD',
 889                    transdate     => DateTime->now->to_kivitendo,
 890                    memo          => 'foobar',
 891                    source        => 'barfoo',
 892                    payment_type  => 'with_skonto_pt',
 893                   );
 894
 895 Allowed payment types are:
 896   without_skonto with_skonto_pt
 897
 898 The option C<payment_type> allows for a basic skonto mechanism.
 899
 900 C<without_skonto> is the default mode, "amount" is paid to the account in
 901 chart_id. This can also be used for partial payments and corrections via
 902 negative amounts.
 903
 904 C<with_skonto_pt> can't be used for partial payments. When used on unpaid
 905 invoices the whole amount is paid, with the skonto part automatically being
 906 booked according to the skonto chart configured in the tax settings for each
 907 tax key. If an amount is passed it is ignored and the actual configured skonto
 908 amount is used.
 909
 910 So passing amount doesn't have any effect for the case C<with_skonto_pt>.
 911
 912 The skonto modes automatically calculate the relative amounts for a mix of
 913 taxes, e.g. items with 7% and 19% in one invoice. There is a helper method
 914 _skonto_charts_and_tax_correction, which calculates the relative percentages
 915 according to the amounts in acc_trans grouped by different tax rates.
 916
 917 The helper method also generates the tax correction for the skonto booking
 918 and links this to the original bank transaction and the selected record.
 919
 920 There is currently no way of excluding certain items in an invoice from having
 921 skonto applied to them.  If this feature was added to parts the calculation
 922 method of relative skonto would have to be completely rewritten using the
 923 invoice items rather than acc_trans.
 924
 925 Because of the way skonto_charts works the calculation doesn't work if there
 926 are negative values in acc_trans. E.g. one invoice with a positive value for
 927 19% tax and a negative value for the acc_trans line with 7%
 928
 929 Skonto doesn't/shouldn't apply if the invoice contains credited items.
 930
 931 If no amount is given the whole open amout is paid.
 932
 933 If neither currency or currency_id are given as params, the currency of the
 934 invoice is assumed to be the payment currency.
 935
 936 If successful the return value will be 1 in scalar context or in list context
 937 the two or more (gl transaction for skonto tax correction) ids (acc_trans_id)
 938 of the newly created bookings.
 939
 940
 941 =item C<reference_account>
 942
 943 Returns a chart object which is the chart of the invoice with link AR or AP.
 944
 945 Example (1200 is the AR account for SKR04):
 946   my $invoice = invoice(invnumber => '144');
 947   $invoice->reference_account->accno
 948   # 1200
 949
 950 =item C<percent_skonto>
 951
 952 Returns the configured skonto percentage of the payment terms of an invoice,
 953 e.g. 0.02 for 2%. Payment terms come from invoice settingssettings for ap.
 954
 955 =item C<amount_less_skonto>
 956
 957 If the invoice has a payment term,
 958 calculate the amount to be paid in the case of skonto.  This doesn't check,
 959 whether skonto applies (i.e. skonto doesn't wasn't exceeded), it just subtracts
 960 the configured percentage (e.g. 2%) from the total amount.
 961
 962 The returned value is rounded to two decimals.
 963
 964 =item C<skonto_date>
 965
 966 The date up to which skonto may be taken. This is calculated from the invoice
 967 date + the number of days configured in the payment terms.
 968
 969 This method can also be used to determine whether skonto applies for the
 970 invoice, as it returns undef if there is no payment term or skonto days is set
 971 to 0.
 972
 973 =item C<within_skonto_period [DATE]>
 974
 975 Returns 0 or 1.
 976
 977 Checks whether the invoice has payment terms configured, and whether the date
 978 is within the skonto max date. If no date is passed the current date is used.
 979
 980 You can also pass a dateref object as a parameter to check whether skonto
 981 applies for that date rather than the current date.
 982
 983 =item C<valid_skonto_amount>
 984
 985 Takes an amount as an argument and checks whether the amount is less than 10%
 986 of the total amount of the invoice. The value of 10% is currently hardcoded in
 987 the method. This method is currently used to check whether to offer the payment
 988 option "difference as skonto".
 989
 990 Example:
 991  if ( $invoice->valid_skonto_amount($invoice->open_amount) ) {
 992    # ... do something
 993  }
 994
 995 =item C<_skonto_charts_and_tax_correction [amount => $amount, bt_id => $bank_transaction.id, transdate_ojb => DateTime]>
 996
 997 Needs a valid bank_transaction id and the transdate of the bank_transaction as
 998 a DateTime object.
 999 If no amout is passed, the currently open invoice amount will be used.
1000
1001 Returns a list of chart_ids and some calculated numbers that can be used for
1002 paying the invoice with skonto. This function will automatically calculate the
1003 relative skonto amounts even if the invoice contains several types of taxes
1004 (e.g. 7% and 19%).
1005
1006 Example usage:
1007   my $invoice = SL::DB::Manager::Invoice->find_by(invnumber => '211');
1008   my @skonto_charts = $invoice->_skonto_charts_and_tax_correction(bt_id         => $bt_id,
1009                                                                   transdate_obj => $transdate_obj);
1010
1011 or with the total skonto amount as an argument:
1012   my @skonto_charts = $invoice->_skonto_charts_and_tax_correction(amount => $invoice->open_amount,
1013                                                                   bt_id  => $bt_id,
1014                                                                   transdate_obj => $transdate_obj);
1015
1016 The following values are generated for each chart:
1017
1018 =over 2
1019
1020 =item C<chart_id>
1021
1022 The chart id of the skonto amount to be booked.
1023
1024 =item C<skonto_amount>
1025
1026 The total amount to be paid to the account
1027
1028 =back
1029
1030 If the invoice contains several types of taxes then skonto_charts can be used
1031 to calculate the relative amounts.
1032
1033 C<_skonto_charts_and_tax_correction> generates one entry for each tax type entry.
1034
1035 =item C<open_amount>
1036
1037 Unrounded total open amount of invoice (amount - paid).
1038 Doesn't take into account pending SEPA transfers.
1039
1040 =item C<open_percent>
1041
1042 Percentage of the invoice that is still unpaid, e.g. 100,00 if no payments have
1043 been made yet, 0,00 if fully paid.
1044
1045 =item C<remaining_skonto_days>
1046
1047 How many days skonto can still be taken, calculated from current day. Returns 0
1048 if current day is the max skonto date, and negative number if skonto date has
1049 already passed.
1050
1051 Returns undef if skonto is not configured for that invoice.
1052
1053 =item C<get_payment_suggestions %params>
1054
1055 Creates data intended for an L.select_tag dropdown that can be used in a
1056 template. Depending on the rules it will choose from the options
1057 without_skonto and with_skonto_pt and select the most
1058 likely one.
1059
1060 If the parameter "sepa" is passed, the SEPA export payments that haven't been
1061 executed yet are considered when determining the open amount of the invoice.
1062
1063 The current rules are:
1064
1065 =over 2
1066
1067 =item * without_skonto is always an option
1068
1069 =item * with_skonto_pt is only offered if there haven't been any payments yet and the current date is within the skonto period.
1070
1071 with_skonto_pt will only be offered, if all the AR_amount/AP_amount have a
1072 taxkey with a configured skonto chart
1073
1074 =back
1075
1076 It will also fill $self->{invoice_amount_suggestion} with either the open
1077 amount, or if with_skonto_pt is selected, with amount_less_skonto, so the
1078 template can fill the input with the likely amount.
1079
1080 Example in console:
1081   my $ar = invoice( invnumber => '257');
1082   $ar->get_payment_suggestions;
1083   print $ar->{invoice_amount_suggestion} . "\n";
1084   # 97.23
1085   pp $ar->{payment_select_options}
1086   # $VAR1 = [
1087   #         {
1088   #           'display' => 'ohne Skonto',
1089   #           'payment_type' => 'without_skonto'
1090   #         },
1091   #         {
1092   #           'display' => 'mit Skonto nach ZB',
1093   #           'payment_type' => 'with_skonto_pt',
1094   #           'selected' => 1
1095   #         }
1096   #       ];
1097
1098 The resulting array $ar->{payment_select_options} can be used in a template
1099 select_tag using value_key and title_key:
1100
1101 [% L.select_tag('payment_type_' _ loop.count, invoice.payment_select_options, value_key => 'payment_type', title_key => 'display', id => 'payment_type_' _ loop.count) %]
1102
1103 It would probably make sense to have different rules for the pre-selected items
1104 for sales and purchase, and to also make these rules configurable in the
1105 defaults. E.g. when creating a SEPA bank transfer for vendor invoices a company
1106 might always want to pay quickly making use of skonto, while another company
1107 might always want to pay as late as possible.
1108
1109 =item C<get_payment_select_options_for_bank_transaction $banktransaction_id %params>
1110
1111 Make suggestion for a skonto payment type by returning an HTML blob of the options
1112 of a HTML drop-down select with the most likely option preselected.
1113
1114 This is a helper function for BankTransaction/ajax_payment_suggestion and
1115 template/webpages/bank_transactions/invoices.html
1116
1117 We are working with an existing payment, so (deprecated) difference_as_skonto never makes sense.
1118
1119 If skonto is not possible (skonto_date does not exists) simply return
1120 the single 'no skonto' option as a visual hint.
1121
1122 If skonto is possible (skonto_date exists), add two possibilities:
1123 without_skonto and with_skonto_pt if payment date is within skonto_date,
1124 preselect with_skonto_pt, otherwise preselect without skonto.
1125
1126 =item C<exchangerate>
1127
1128 Returns 1 immediately if the record uses the default currency.
1129
1130 Returns the exchangerate in database format for the invoice according to that
1131 invoice's transdate, returning 'buy' for sales, 'sell' for purchases.
1132
1133 If no exchangerate can be found for that day undef is returned.
1134
1135 =item C<forex>
1136
1137 Returns 1 if record uses a different currency, 0 if the default currency is used.
1138
1139 =back
1140
1141 =head1 TODO AND CAVEATS
1142
1143 =over 4
1144
1145 =item *
1146
1147 when looking at open amount, maybe consider that there may already be queued
1148 amounts in SEPA Export
1149
1150 =item * C<_skonto_charts_and_tax_correction>
1151
1152 Cannot handle negative skonto amounts, will always calculate the skonto amount
1153 for credit notes or negative ap transactions with a positive sign.
1154
1155
1156 =back
1157
1158 =head1 AUTHOR
1159
1160 G. Richardson E<lt>grichardson@kivitendo-premium.de<gt>
1161
1162 =cut