Upgrade-Doku: Hinweis auf benötigtes Perl-Modul IPC::Run
[kivitendo-erp.git] / 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