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