Mahnungsbericht: Webdav-Dateien f. Mahnlauf anzeigen
[kivitendo-erp.git] / SL / DB / Invoice.pm
1 package SL::DB::Invoice;
2
3 use strict;
4
5 use Carp;
6 use List::Util qw(first sum);
7
8 use Rose::DB::Object::Helpers qw(has_loaded_related forget_related);
9 use SL::DB::MetaSetup::Invoice;
10 use SL::DB::Manager::Invoice;
11 use SL::DB::Helper::Payment qw(:ALL);
12 use SL::DB::Helper::AttrHTML;
13 use SL::DB::Helper::AttrSorted;
14 use SL::DB::Helper::FlattenToForm;
15 use SL::DB::Helper::LinkedRecords;
16 use SL::DB::Helper::PDF_A;
17 use SL::DB::Helper::PriceTaxCalculator;
18 use SL::DB::Helper::PriceUpdater;
19 use SL::DB::Helper::TransNumberGenerator;
20 use SL::DB::Helper::ZUGFeRD;
21 use SL::Locale::String qw(t8);
22 use SL::DB::CustomVariable;
23
24 __PACKAGE__->meta->add_relationship(
25   invoiceitems => {
26     type         => 'one to many',
27     class        => 'SL::DB::InvoiceItem',
28     column_map   => { id => 'trans_id' },
29     manager_args => {
30       with_objects => [ 'part' ]
31     }
32   },
33   storno_invoices => {
34     type          => 'one to many',
35     class         => 'SL::DB::Invoice',
36     column_map    => { id => 'storno_id' },
37   },
38   sepa_export_items => {
39     type            => 'one to many',
40     class           => 'SL::DB::SepaExportItem',
41     column_map      => { id => 'ar_id' },
42     manager_args    => { with_objects => [ 'sepa_export' ] }
43   },
44   sepa_exports      => {
45     type            => 'many to many',
46     map_class       => 'SL::DB::SepaExportItem',
47     map_from        => 'ar',
48     map_to          => 'sepa_export',
49   },
50   custom_shipto     => {
51     type            => 'one to one',
52     class           => 'SL::DB::Shipto',
53     column_map      => { id => 'trans_id' },
54     query_args      => [ module => 'AR' ],
55   },
56   transactions   => {
57     type         => 'one to many',
58     class        => 'SL::DB::AccTransaction',
59     column_map   => { id => 'trans_id' },
60     manager_args => {
61       with_objects => [ 'chart' ],
62       sort_by      => 'acc_trans_id ASC',
63     },
64   },
65   dunnings       => {
66     type         => 'one to many',
67     class        => 'SL::DB::Dunning',
68     column_map   => { id => 'trans_id' },
69     manager_args => { with_objects => [ 'dunnings' ] }
70   },
71 );
72
73 __PACKAGE__->meta->initialize;
74
75 __PACKAGE__->attr_html('notes');
76 __PACKAGE__->attr_sorted('items');
77
78 __PACKAGE__->before_save('_before_save_set_invnumber');
79
80 # hooks
81
82 sub _before_save_set_invnumber {
83   my ($self) = @_;
84
85   $self->create_trans_number if !$self->invnumber;
86
87   return 1;
88 }
89
90 # methods
91
92 sub items { goto &invoiceitems; }
93 sub add_items { goto &add_invoiceitems; }
94 sub record_number { goto &invnumber; };
95
96 sub is_sales {
97   # For compatibility with Order, DeliveryOrder
98   croak 'not an accessor' if @_ > 1;
99   return 1;
100 }
101
102 # it is assumed, that ordnumbers are unique here.
103 sub first_order_by_ordnumber {
104   my $self = shift;
105
106   my $orders = SL::DB::Manager::Order->get_all(
107     query => [
108       ordnumber => $self->ordnumber,
109
110     ],
111   );
112
113   return first { $_->is_type('sales_order') } @{ $orders };
114 }
115
116 sub abschlag_percentage {
117   my $self         = shift;
118   my $order        = $self->first_order_by_ordnumber or return;
119   my $order_amount = $order->netamount               or return;
120   return $self->abschlag
121     ? $self->netamount / $order_amount
122     : undef;
123 }
124
125 sub taxamount {
126   my $self = shift;
127   die 'not a setter method' if @_;
128
129   return ($self->amount || 0) - ($self->netamount || 0);
130 }
131
132 __PACKAGE__->meta->make_attr_helpers(taxamount => 'numeric(15,5)');
133
134 sub closed {
135   my ($self) = @_;
136   return $self->paid >= $self->amount;
137 }
138
139 sub _clone_orderitem_delivery_order_item_cvar {
140   my ($cvar) = @_;
141
142   my $cloned = $_->clone_and_reset;
143   $cloned->sub_module('invoice');
144
145   return $cloned;
146 }
147
148 sub new_from {
149   my ($class, $source, %params) = @_;
150
151   croak("Unsupported source object type '" . ref($source) . "'") unless ref($source) =~ m/^ SL::DB:: (?: Order | DeliveryOrder ) $/x;
152   croak("Cannot create invoices for purchase records")           unless $source->customer_id;
153
154   require SL::DB::Employee;
155
156   my (@columns, @item_columns, $item_parent_id_column, $item_parent_column);
157
158   if (ref($source) eq 'SL::DB::Order') {
159     @columns      = qw(quonumber delivery_customer_id delivery_vendor_id tax_point);
160     @item_columns = qw(subtotal);
161
162     $item_parent_id_column = 'trans_id';
163     $item_parent_column    = 'order';
164
165   } else {
166     @columns      = qw(donumber);
167
168     $item_parent_id_column = 'delivery_order_id';
169     $item_parent_column    = 'delivery_order';
170   }
171
172   my $terms = $source->can('payment_id') ? $source->payment_terms : undef;
173   $terms = $source->customer->payment_terms if !defined $terms && $source->customer;
174
175   my %args = ( map({ ( $_ => $source->$_ ) } qw(customer_id taxincluded shippingpoint shipvia notes intnotes salesman_id cusordnumber ordnumber department_id
176                                                 cp_id language_id taxzone_id tax_point globalproject_id transaction_description currency_id delivery_term_id), @columns),
177                transdate   => $params{transdate} // DateTime->today_local,
178                gldate      => DateTime->today_local,
179                duedate     => $terms ? $terms->calc_date(reference_date => DateTime->today_local) : DateTime->today_local,
180                invoice     => 1,
181                type        => 'invoice',
182                storno      => 0,
183                paid        => 0,
184                employee_id => (SL::DB::Manager::Employee->current || SL::DB::Employee->new(id => $source->employee_id))->id,
185             );
186
187   $args{payment_id} = ( $terms ? $terms->id : $source->payment_id);
188
189   if ($source->type =~ /_delivery_order$/) {
190     $args{deliverydate} = $source->reqdate;
191     if (my $order = SL::DB::Manager::Order->find_by(ordnumber => $source->ordnumber)) {
192       $args{orddate}    = $order->transdate;
193     }
194
195   } elsif ($source->type =~ /_order$/) {
196     $args{deliverydate} = $source->reqdate;
197     $args{orddate}      = $source->transdate;
198
199   } else {
200     $args{quodate}      = $source->transdate;
201   }
202
203   # Custom shipto addresses (the ones specific to the sales/purchase
204   # record and not to the customer/vendor) are only linked from shipto
205   # â†’ ar. Meaning ar.shipto_id will not be filled in that
206   # case.
207   if (!$source->shipto_id && $source->id) {
208     $args{custom_shipto} = $source->custom_shipto->clone($class) if $source->can('custom_shipto') && $source->custom_shipto;
209
210   } else {
211     $args{shipto_id} = $source->shipto_id;
212   }
213
214   my $invoice = $class->new(%args);
215   $invoice->assign_attributes(%{ $params{attributes} }) if $params{attributes};
216   my $items   = delete($params{items}) || $source->items_sorted;
217   my %item_parents;
218
219   my @items = map {
220     my $source_item      = $_;
221     my $source_item_id   = $_->$item_parent_id_column;
222     my @custom_variables = map { _clone_orderitem_delivery_order_item_cvar($_) } @{ $source_item->custom_variables };
223
224     $item_parents{$source_item_id} ||= $source_item->$item_parent_column;
225     my $item_parent                  = $item_parents{$source_item_id};
226     my $current_invoice_item =
227       SL::DB::InvoiceItem->new(map({ ( $_ => $source_item->$_ ) }
228                                    qw(parts_id description qty sellprice discount project_id serialnumber pricegroup_id transdate cusordnumber unit
229                                       base_qty longdescription lastcost price_factor_id active_discount_source active_price_source), @item_columns),
230                                deliverydate     => $source_item->reqdate,
231                                fxsellprice      => $source_item->sellprice,
232                                custom_variables => \@custom_variables,
233                                ordnumber        => ref($item_parent) eq 'SL::DB::Order'         ? $item_parent->ordnumber : $source_item->ordnumber,
234                                donumber         => ref($item_parent) eq 'SL::DB::DeliveryOrder' ? $item_parent->donumber  : $source_item->can('donumber') ? $source_item->donumber : '',
235                              );
236
237     $current_invoice_item->{"converted_from_orderitems_id"}           = $_->{id} if ref($item_parent) eq 'SL::DB::Order';
238     $current_invoice_item->{"converted_from_delivery_order_items_id"} = $_->{id} if ref($item_parent) eq 'SL::DB::DeliveryOrder';
239     $current_invoice_item;
240   } @{ $items };
241
242   @items = grep { $params{item_filter}->($_) } @items if $params{item_filter};
243   @items = grep { $_->qty * 1 } @items if $params{skip_items_zero_qty};
244   @items = grep { $_->qty >=0 } @items if $params{skip_items_negative_qty};
245
246   $invoice->invoiceitems(\@items);
247
248   return $invoice;
249 }
250
251 sub post {
252   my ($self, %params) = @_;
253
254   die "not an invoice" unless $self->invoice;
255
256   require SL::DB::Chart;
257   if (!$params{ar_id}) {
258     my $chart;
259     if ($::instance_conf->get_ar_chart_id) {
260       $chart = SL::DB::Manager::Chart->find_by(id => $::instance_conf->get_ar_chart_id);
261     } else {
262       $chart = SL::DB::Manager::Chart->get_all(query   => [ SL::DB::Manager::Chart->link_filter('AR') ],
263                                                sort_by => 'id ASC',
264                                                limit   => 1)->[0];
265     };
266     croak("No AR chart found and no parameter 'ar_id' given") unless $chart;
267     $params{ar_id} = $chart->id;
268   }
269
270   if (!$self->db->with_transaction(sub {
271     my %data = $self->calculate_prices_and_taxes;
272
273     $self->_post_create_assemblyitem_entries($data{assembly_items});
274     $self->save;
275
276     $self->_post_add_acctrans($data{amounts_cogs});
277     $self->_post_add_acctrans($data{amounts});
278     $self->_post_add_acctrans($data{taxes_by_chart_id});
279
280     $self->_post_add_acctrans({ $params{ar_id} => $self->amount * -1 });
281
282     $self->_post_update_allocated($data{allocated});
283
284     $self->_post_book_rounding($data{rounding});
285
286     1;
287   })) {
288     $::lxdebug->message(LXDebug->WARN(), "convert_to_invoice failed: " . join("\n", (split(/\n/, $self->db->error))[0..2]));
289     return undef;
290   }
291
292   return $self;
293 }
294
295 sub _post_add_acctrans {
296   my ($self, $entries) = @_;
297
298   my $default_tax_id = SL::DB::Manager::Tax->find_by(taxkey => 0)->id;
299   my $chart_link;
300
301   require SL::DB::AccTransaction;
302   require SL::DB::Chart;
303   while (my ($chart_id, $spec) = each %{ $entries }) {
304     $spec = { taxkey => 0, tax_id => $default_tax_id, amount => $spec } unless ref $spec;
305     $chart_link = SL::DB::Manager::Chart->find_by(id => $chart_id)->{'link'};
306     $chart_link ||= '';
307
308     if ($spec->{amount} != 0) {
309       SL::DB::AccTransaction->new(trans_id   => $self->id,
310                                   chart_id   => $chart_id,
311                                   amount     => $spec->{amount},
312                                   tax_id     => $spec->{tax_id},
313                                   taxkey     => $spec->{taxkey},
314                                   project_id => $self->globalproject_id,
315                                   transdate  => $self->transdate,
316                                   chart_link => $chart_link)->save;
317     }
318   }
319 }
320
321 sub _post_book_rounding {
322   my ($self, $rounding) = @_;
323
324   my $tax_id = SL::DB::Manager::Tax->find_by(taxkey => 0)->id;
325   my $rnd_accno = $rounding == 0 ? 0
326                 : $rounding > 0  ? SL::DB::Default->get->rndgain_accno_id
327                 :                  SL::DB::Default->get->rndloss_accno_id
328   ;
329   if ($rnd_accno != 0) {
330     SL::DB::AccTransaction->new(trans_id   => $self->id,
331                                 chart_id   => $rnd_accno,
332                                 amount     => $rounding,
333                                 tax_id     => $tax_id,
334                                 taxkey     => 0,
335                                 project_id => $self->globalproject_id,
336                                 transdate  => $self->transdate,
337                                 chart_link => $rnd_accno)->save;
338   }
339 }
340
341 sub add_ar_amount_row {
342   my ($self, %params ) = @_;
343
344   # only allow this method for ar invoices (Debitorenbuchung)
345   die "not an ar invoice" if $self->invoice and not $self->customer_id;
346
347   die "add_ar_amount_row needs a chart object as chart param" unless $params{chart} && $params{chart}->isa('SL::DB::Chart');
348   die "chart must be an AR_amount chart" unless $params{chart}->link =~ /AR_amount/;
349
350   my $acc_trans = [];
351
352   my $roundplaces = 2;
353   my ($netamount,$taxamount);
354
355   $netamount = $params{amount} * 1;
356   my $tax = SL::DB::Manager::Tax->find_by(id => $params{tax_id}) || die "Can't find tax with id " . $params{tax_id};
357
358   if ( $tax and $tax->rate != 0 ) {
359     ($netamount, $taxamount) = Form->calculate_tax($params{amount}, $tax->rate, $self->taxincluded, $roundplaces);
360   };
361   next unless $netamount; # netamount mustn't be zero
362
363   my $sign = $self->customer_id ? 1 : -1;
364   my $acc = SL::DB::AccTransaction->new(
365     amount     => $netamount * $sign,
366     chart_id   => $params{chart}->id,
367     chart_link => $params{chart}->link,
368     transdate  => $self->transdate,
369     gldate     => $self->gldate,
370     taxkey     => $tax->taxkey,
371     tax_id     => $tax->id,
372     project_id => $params{project_id},
373   );
374
375   $self->add_transactions( $acc );
376   push( @$acc_trans, $acc );
377
378   if ( $taxamount ) {
379      my $acc = SL::DB::AccTransaction->new(
380        amount     => $taxamount * $sign,
381        chart_id   => $tax->chart_id,
382        chart_link => $tax->chart->link,
383        transdate  => $self->transdate,
384        gldate     => $self->gldate,
385        taxkey     => $tax->taxkey,
386        tax_id     => $tax->id,
387      );
388      $self->add_transactions( $acc );
389      push( @$acc_trans, $acc );
390   };
391   return $acc_trans;
392 };
393
394 sub create_ar_row {
395   my ($self, %params) = @_;
396   # to be called after adding all AR_amount rows, adds an AR row
397
398   # only allow this method for ar invoices (Debitorenbuchung)
399   die if $self->invoice and not $self->customer_id;
400   die "create_ar_row needs a chart object as a parameter" unless $params{chart} and ref($params{chart}) eq 'SL::DB::Chart';
401
402   my @transactions = @{$self->transactions};
403   # die "invoice has no acc_transactions" unless scalar @transactions > 0;
404   return 0 unless scalar @transactions > 0;
405
406   my $chart = $params{chart} || SL::DB::Manager::Chart->find_by(id => $::instance_conf->get_ar_chart_id);
407   die "illegal chart in create_ar_row" unless $chart;
408
409   die "receivables chart must have link 'AR'" unless $chart->link eq 'AR';
410
411   my $acc_trans = [];
412
413   # hardcoded entry for no tax: tax_id and taxkey should be 0
414   my $tax = SL::DB::Manager::Tax->find_by(id => 0, taxkey => 0) || die "Can't find tax with id 0 and taxkey 0";
415
416   my $sign = $self->customer_id ? -1 : 1;
417   my $acc = SL::DB::AccTransaction->new(
418     amount     => $self->amount * $sign,
419     chart_id   => $params{chart}->id,
420     chart_link => $params{chart}->link,
421     transdate  => $self->transdate,
422     taxkey     => $tax->taxkey,
423     tax_id     => $tax->id,
424   );
425   $self->add_transactions( $acc );
426   push( @$acc_trans, $acc );
427   return $acc_trans;
428 };
429
430 sub validate_acc_trans {
431   my ($self, %params) = @_;
432   # should be able to check unsaved invoice objects with several acc_trans lines
433
434   die "validate_acc_trans can't check invoice object with empty transactions" unless $self->transactions;
435
436   my @transactions = @{$self->transactions};
437   # die "invoice has no acc_transactions" unless scalar @transactions > 0;
438   return 0 unless scalar @transactions > 0;
439   return 0 unless $self->has_loaded_related('transactions');
440   if ( $params{debug} ) {
441     printf("starting validatation of invoice %s with trans_id %s and taxincluded %s\n", $self->invnumber, $self->id, $self->taxincluded);
442     foreach my $acc ( @transactions ) {
443       printf("chart: %s  amount: %s   tax_id: %s  link: %s\n", $acc->chart->accno, $acc->amount, $acc->tax_id, $acc->chart->link);
444     };
445   };
446
447   my $acc_trans_sum = sum map { $_->amount } @transactions;
448
449   unless ( $::form->round_amount($acc_trans_sum, 10) == 0 ) {
450     my $string = "sum of acc_transactions isn't 0: $acc_trans_sum\n";
451
452     if ( $params{debug} ) {
453       foreach my $trans ( @transactions ) {
454           $string .= sprintf("  %s %s %s\n", $trans->chart->accno, $trans->taxkey, $trans->amount);
455       };
456     };
457     return 0;
458   };
459
460   # only use the first AR entry, so it also works for paid invoices
461   my @ar_transactions = map { $_->amount } grep { $_->chart_link eq 'AR' } @transactions;
462   my $ar_sum = $ar_transactions[0];
463   # my $ar_sum = sum map { $_->amount } grep { $_->chart_link eq 'AR' } @transactions;
464
465   unless ( $::form->round_amount($ar_sum * -1,2) == $::form->round_amount($self->amount,2) ) {
466     if ( $params{debug} ) {
467       printf("debug: (ar_sum) %s = %s (amount)\n",  $::form->round_amount($ar_sum * -1,2) , $::form->round_amount($self->amount, 2) );
468       foreach my $trans ( @transactions ) {
469         printf("  %s %s %s %s\n", $trans->chart->accno, $trans->taxkey, $trans->amount, $trans->chart->link);
470       };
471     };
472     die sprintf("sum of ar (%s) isn't equal to invoice amount (%s)", $::form->round_amount($ar_sum * -1,2), $::form->round_amount($self->amount,2));
473   };
474
475   return 1;
476 };
477
478 sub recalculate_amounts {
479   my ($self, %params) = @_;
480   # calculate and set amount and netamount from acc_trans objects
481
482   croak ("Can only recalculate amounts for ar transactions") if $self->invoice;
483
484   return undef unless $self->has_loaded_related('transactions');
485
486   my ($netamount, $taxamount);
487
488   my @transactions = @{$self->transactions};
489
490   foreach my $acc ( @transactions ) {
491     $netamount += $acc->amount if $acc->chart->link =~ /AR_amount/;
492     $taxamount += $acc->amount if $acc->chart->link =~ /AR_tax/;
493   };
494
495   $self->amount($netamount+$taxamount);
496   $self->netamount($netamount);
497 };
498
499
500 sub _post_create_assemblyitem_entries {
501   my ($self, $assembly_entries) = @_;
502
503   my $items = $self->invoiceitems;
504   my @new_items;
505
506   my $item_idx = 0;
507   foreach my $item (@{ $items }) {
508     next if $item->assemblyitem;
509
510     push @new_items, $item;
511     $item_idx++;
512
513     foreach my $assembly_item (@{ $assembly_entries->[$item_idx] || [ ] }) {
514       push @new_items, SL::DB::InvoiceItem->new(parts_id     => $assembly_item->{part},
515                                                 description  => $assembly_item->{part}->description,
516                                                 unit         => $assembly_item->{part}->unit,
517                                                 qty          => $assembly_item->{qty},
518                                                 allocated    => $assembly_item->{allocated},
519                                                 sellprice    => 0,
520                                                 fxsellprice  => 0,
521                                                 assemblyitem => 't');
522     }
523   }
524
525   $self->invoiceitems(\@new_items);
526 }
527
528 sub _post_update_allocated {
529   my ($self, $allocated) = @_;
530
531   while (my ($invoice_id, $diff) = each %{ $allocated }) {
532     SL::DB::Manager::InvoiceItem->update_all(set   => { allocated => { sql => "allocated + $diff" } },
533                                              where => [ id        => $invoice_id ]);
534   }
535 }
536
537 sub invoice_type {
538   my ($self) = @_;
539
540   return 'ar_transaction'     if !$self->invoice;
541   return 'credit_note'        if $self->type eq 'credit_note' && $self->amount < 0 && !$self->storno;
542   return 'invoice_storno'     if $self->type ne 'credit_note' && $self->amount < 0 &&  $self->storno;
543   return 'credit_note_storno' if $self->type eq 'credit_note' && $self->amount > 0 &&  $self->storno;
544   return 'invoice';
545 }
546
547 sub displayable_state {
548   my $self = shift;
549
550   return $self->closed ? $::locale->text('closed') : $::locale->text('open');
551 }
552
553 sub displayable_type {
554   my ($self) = @_;
555
556   return t8('AR Transaction')                         if $self->invoice_type eq 'ar_transaction';
557   return t8('Credit Note')                            if $self->invoice_type eq 'credit_note';
558   return t8('Invoice') . "(" . t8('Storno') . ")"     if $self->invoice_type eq 'invoice_storno';
559   return t8('Credit Note') . "(" . t8('Storno') . ")" if $self->invoice_type eq 'credit_note_storno';
560   return t8('Invoice');
561 }
562
563 sub displayable_name {
564   join ' ', grep $_, map $_[0]->$_, qw(displayable_type record_number);
565 };
566
567 sub abbreviation {
568   my ($self) = @_;
569
570   return t8('AR Transaction (abbreviation)')         if $self->invoice_type eq 'ar_transaction';
571   return t8('Credit note (one letter abbreviation)') if $self->invoice_type eq 'credit_note';
572   return t8('Invoice (one letter abbreviation)') . "(" . t8('Storno (one letter abbreviation)') . ")" if $self->invoice_type eq 'invoice_storno';
573   return t8('Credit note (one letter abbreviation)') . "(" . t8('Storno (one letter abbreviation)') . ")"  if $self->invoice_type eq 'credit_note_storno';
574   return t8('Invoice (one letter abbreviation)');
575 }
576
577 sub oneline_summary {
578   my $self = shift;
579
580   return sprintf("%s: %s %s %s (%s)", $self->abbreviation, $self->invnumber, $self->customer->name,
581                                       $::form->format_amount(\%::myconfig, $self->amount,2), $self->transdate->to_kivitendo);
582 }
583
584 sub date {
585   goto &transdate;
586 }
587
588 sub reqdate {
589   goto &duedate;
590 }
591
592 sub customervendor {
593   goto &customer;
594 }
595
596 sub link {
597   my ($self) = @_;
598
599   my $html;
600   $html   = $self->presenter->sales_invoice(display => 'inline') if $self->invoice;
601   $html   = $self->presenter->ar_transaction(display => 'inline') if !$self->invoice;
602
603   return $html;
604 }
605
606 sub mark_as_paid {
607   my ($self) = @_;
608
609   $self->update_attributes(paid => $self->amount);
610 }
611
612 sub effective_tax_point {
613   my ($self) = @_;
614
615   return $self->tax_point || $self->deliverydate || $self->transdate;
616 }
617
618 1;
619
620 __END__
621
622 =pod
623
624 =encoding UTF-8
625
626 =head1 NAME
627
628 SL::DB::Invoice: Rose model for invoices (table "ar")
629
630 =head1 FUNCTIONS
631
632 =over 4
633
634 =item C<new_from $source, %params>
635
636 Creates a new C<SL::DB::Invoice> instance and copies as much
637 information from C<$source> as possible. At the moment only sales
638 orders and sales quotations are supported as sources.
639
640 The conversion copies order items into invoice items. Dates are copied
641 as appropriate, e.g. the C<transdate> field from an order will be
642 copied into the invoice's C<orddate> field.
643
644 C<%params> can include the following options:
645
646 =over 2
647
648 =item C<items>
649
650 An optional array reference of RDBO instances for the items to use. If
651 missing then the method C<items_sorted> will be called on
652 C<$source>. This option can be used to override the sorting, to
653 exclude certain positions or to add additional ones.
654
655 =item C<skip_items_negative_qty>
656
657 If trueish then items with a negative quantity are skipped. Items with
658 a quantity of 0 are not affected by this option.
659
660 =item C<skip_items_zero_qty>
661
662 If trueish then items with a quantity of 0 are skipped.
663
664 =item C<item_filter>
665
666 An optional code reference that is called for each item with the item
667 as its sole parameter. Items for which the code reference returns a
668 falsish value will be skipped.
669
670 =item C<attributes>
671
672 An optional hash reference. If it exists then it is passed to C<new>
673 allowing the caller to set certain attributes for the new invoice.
674 For example to set a different transdate (default is the current date),
675 call the method like this:
676
677    my %params;
678    $params{attributes}{transdate} = '28.08.2015';
679    $invoice = SL::DB::Invoice->new_from($self, %params)->post || die;
680
681 =back
682
683 Amounts, prices and taxes are not
684 calculated. L<SL::DB::Helper::PriceTaxCalculator::calculate_prices_and_taxes>
685 can be used for this.
686
687 The object returned is not saved.
688
689 =item C<post %params>
690
691 Posts the invoice. Required parameters are:
692
693 =over 2
694
695 =item * C<ar_id>
696
697 The ID of the accounts receivable chart the invoice's amounts are
698 posted to. If it is not set then the first chart configured for
699 accounts receivables is used.
700
701 =back
702
703 This function implements several steps:
704
705 =over 2
706
707 =item 1. It calculates all prices, amounts and taxes by calling
708 L<SL::DB::Helper::PriceTaxCalculator::calculate_prices_and_taxes>.
709
710 =item 2. A new and unique invoice number is created.
711
712 =item 3. All amounts for costs of goods sold are recorded in
713 C<acc_trans>.
714
715 =item 4. All amounts for parts, services and assemblies are recorded
716 in C<acc_trans> with their respective charts. This is determined by
717 the part's buchungsgruppen.
718
719 =item 5. The total amount is posted to the accounts receivable chart
720 and recorded in C<acc_trans>.
721
722 =item 6. Items in C<invoice> are updated according to their allocation
723 status (regarding costs of goods sold). Will only be done if
724 kivitendo is not configured to use Einnahmenüberschussrechnungen.
725
726 =item 7. The invoice and its items are saved.
727
728 =back
729
730 Returns C<$self> on success and C<undef> on failure. The whole process
731 is run inside a transaction. If it fails then nothing is saved to or
732 changed in the database. A new transaction is only started if none are
733 active.
734
735 =item C<basic_info $field>
736
737 See L<SL::DB::Object::basic_info>.
738
739 =item C<closed>
740
741 Returns 1 or 0, depending on whether the invoice is closed or not. Currently
742 invoices that are overpaid also count as closed and credit notes in general.
743
744 =item C<recalculate_amounts %params>
745
746 Calculate and set amount and netamount from acc_trans objects by summing up the
747 values of acc_trans objects with AR_amount and AR_tax link charts.
748 amount and netamount are set to the calculated values.
749
750 =item C<validate_acc_trans>
751
752 Checks if the sum of all associated acc_trans objects is 0 and checks whether
753 the amount of the AR acc_transaction matches the AR amount. Only the first AR
754 line is checked, because the sum of all AR lines is 0 for paid invoices.
755
756 Returns 0 or 1.
757
758 Can be called with a debug parameter which writes debug info to STDOUT, which is
759 useful in console mode or while writing tests.
760
761  my $ar = SL::DB::Manager::Invoice->get_first();
762  $ar->validate_acc_trans(debug => 1);
763
764 =item C<create_ar_row %params>
765
766 Creates a new acc_trans entry for the receivable (AR) entry of an existing AR
767 invoice object, which already has some income and tax acc_trans entries.
768
769 The acc_trans entry is also returned inside an array ref.
770
771 Mandatory params are
772
773 =over 2
774
775 =item * chart as an RDBO object, e.g. for bank. Must be a 'paid' chart.
776
777 =back
778
779 Currently the amount of the invoice object is used for the acc_trans amount.
780 Use C<recalculate_amounts> before calling this method if amount isn't known
781 yet or you didn't set it manually.
782
783 =item C<add_ar_amount_row %params>
784
785 Add a new entry for an existing AR invoice object. Creates an acc_trans entry,
786 and also adds an acc_trans tax entry, if the tax has an associated tax chart.
787 Also all acc_trans entries that were created are returned inside an array ref.
788
789 Mandatory params are
790
791 =over 2
792
793 =item * chart as an RDBO object, should be an income chart (link = AR_amount)
794
795 =item * tax_id
796
797 =item * amount
798
799 =back
800
801 =item C<mark_as_paid>
802
803 Marks the invoice as paid by setting its C<paid> member to the value of C<amount>.
804
805 =back
806
807 =head1 TODO
808
809  As explained in the new_from example, it is possible to set transdate to a new value.
810  From a user / programm point of view transdate is more than holy and there should be
811  some validity checker available for controller code. At least the same logic like in
812  Form.pm from ar.pl should be available:
813   # see old stuff ar.pl post
814   #$form->error($locale->text('Cannot post transaction above the maximum future booking date!'))
815   #  if ($form->date_max_future($transdate, \%myconfig));
816   #$form->error($locale->text('Cannot post transaction for a closed period!')) if ($form->date_closed($form->{"transdate"}, \%myconfig));
817
818 =head1 AUTHOR
819
820 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
821
822 =cut