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   return 'final_invoice'                      if $self->type eq 'final_invoice';
 545   # stornoed credit_notes are still credit notes and not invoices
 546   return 'credit_note'        if $self->type eq 'credit_note' && $self->amount < 0;
 547   return 'invoice_storno'     if $self->type ne 'credit_note' && $self->amount < 0 &&  $self->storno;
 548   return 'credit_note_storno' if $self->type eq 'credit_note' && $self->amount > 0 &&  $self->storno;
 549   return 'invoice';
 550 }
 551
 552 sub displayable_state {
 553   my $self = shift;
 554
 555   return $self->closed ? $::locale->text('closed') : $::locale->text('open');
 556 }
 557
 558 sub displayable_type {
 559   my ($self) = @_;
 560
 561   return t8('AR Transaction')                         if $self->invoice_type eq 'ar_transaction';
 562   return t8('Credit Note')                            if $self->invoice_type eq 'credit_note';
 563   return t8('Invoice') . "(" . t8('Storno') . ")"     if $self->invoice_type eq 'invoice_storno';
 564   return t8('Credit Note') . "(" . t8('Storno') . ")" if $self->invoice_type eq 'credit_note_storno';
 565   return t8('Invoice for Advance Payment')            if $self->invoice_type eq 'invoice_for_advance_payment';
 566   return t8('Invoice for Advance Payment') . "(" . t8('Storno') . ")" if $self->invoice_type eq 'invoice_for_advance_payment_storno';
 567   return t8('Final Invoice')                          if $self->invoice_type eq 'final_invoice';
 568   return t8('Invoice');
 569 }
 570
 571 sub displayable_name {
 572   join ' ', grep $_, map $_[0]->$_, qw(displayable_type record_number);
 573 };
 574
 575 sub abbreviation {
 576   my ($self) = @_;
 577
 578   return t8('AR Transaction (abbreviation)')         if $self->invoice_type eq 'ar_transaction';
 579   return t8('Credit note (one letter abbreviation)') if $self->invoice_type eq 'credit_note';
 580   return t8('Invoice (one letter abbreviation)') . "(" . t8('Storno (one letter abbreviation)') . ")" if $self->invoice_type eq 'invoice_storno';
 581   return t8('Credit note (one letter abbreviation)') . "(" . t8('Storno (one letter abbreviation)') . ")"  if $self->invoice_type eq 'credit_note_storno';
 582   return t8('Invoice for Advance Payment (one letter abbreviation)')  if $self->invoice_type eq 'invoice_for_advance_payment';
 583   return t8('Invoice for Advance Payment with Storno (abbreviation)') if $self->invoice_type eq 'invoice_for_advance_payment_storno';
 584   return t8('Final Invoice (one letter abbreviation)')                if $self->invoice_type eq 'final_invoice';
 585   return t8('Invoice (one letter abbreviation)');
 586 }
 587
 588 sub oneline_summary {
 589   my $self = shift;
 590
 591   return sprintf("%s: %s %s %s (%s)", $self->abbreviation, $self->invnumber, $self->customer->name,
 592                                       $::form->format_amount(\%::myconfig, $self->amount,2), $self->transdate->to_kivitendo);
 593 }
 594
 595 sub date {
 596   goto &transdate;
 597 }
 598
 599 sub reqdate {
 600   goto &duedate;
 601 }
 602
 603 sub customervendor {
 604   goto &customer;
 605 }
 606
 607 sub link {
 608   my ($self) = @_;
 609
 610   my $html;
 611   $html   = $self->presenter->sales_invoice(display => 'inline') if $self->invoice;
 612   $html   = $self->presenter->ar_transaction(display => 'inline') if !$self->invoice;
 613
 614   return $html;
 615 }
 616
 617 sub mark_as_paid {
 618   my ($self) = @_;
 619
 620   $self->update_attributes(paid => $self->amount);
 621 }
 622
 623 sub effective_tax_point {
 624   my ($self) = @_;
 625
 626   return $self->tax_point || $self->deliverydate || $self->transdate;
 627 }
 628
 629 1;
 630
 631 __END__
 632
 633 =pod
 634
 635 =encoding UTF-8
 636
 637 =head1 NAME
 638
 639 SL::DB::Invoice: Rose model for invoices (table "ar")
 640
 641 =head1 FUNCTIONS
 642
 643 =over 4
 644
 645 =item C<new_from $source, %params>
 646
 647 Creates a new C<SL::DB::Invoice> instance and copies as much
 648 information from C<$source> as possible. At the moment only sales
 649 orders and sales quotations are supported as sources.
 650
 651 The conversion copies order items into invoice items. Dates are copied
 652 as appropriate, e.g. the C<transdate> field from an order will be
 653 copied into the invoice's C<orddate> field.
 654
 655 C<%params> can include the following options:
 656
 657 =over 2
 658
 659 =item C<items>
 660
 661 An optional array reference of RDBO instances for the items to use. If
 662 missing then the method C<items_sorted> will be called on
 663 C<$source>. This option can be used to override the sorting, to
 664 exclude certain positions or to add additional ones.
 665
 666 =item C<skip_items_negative_qty>
 667
 668 If trueish then items with a negative quantity are skipped. Items with
 669 a quantity of 0 are not affected by this option.
 670
 671 =item C<skip_items_zero_qty>
 672
 673 If trueish then items with a quantity of 0 are skipped.
 674
 675 =item C<item_filter>
 676
 677 An optional code reference that is called for each item with the item
 678 as its sole parameter. Items for which the code reference returns a
 679 falsish value will be skipped.
 680
 681 =item C<attributes>
 682
 683 An optional hash reference. If it exists then it is passed to C<new>
 684 allowing the caller to set certain attributes for the new invoice.
 685 For example to set a different transdate (default is the current date),
 686 call the method like this:
 687
 688    my %params;
 689    $params{attributes}{transdate} = '28.08.2015';
 690    $invoice = SL::DB::Invoice->new_from($self, %params)->post || die;
 691
 692 =back
 693
 694 Amounts, prices and taxes are not
 695 calculated. L<SL::DB::Helper::PriceTaxCalculator::calculate_prices_and_taxes>
 696 can be used for this.
 697
 698 The object returned is not saved.
 699
 700 =item C<post %params>
 701
 702 Posts the invoice. Required parameters are:
 703
 704 =over 2
 705
 706 =item * C<ar_id>
 707
 708 The ID of the accounts receivable chart the invoice's amounts are
 709 posted to. If it is not set then the first chart configured for
 710 accounts receivables is used.
 711
 712 =back
 713
 714 This function implements several steps:
 715
 716 =over 2
 717
 718 =item 1. It calculates all prices, amounts and taxes by calling
 719 L<SL::DB::Helper::PriceTaxCalculator::calculate_prices_and_taxes>.
 720
 721 =item 2. A new and unique invoice number is created.
 722
 723 =item 3. All amounts for costs of goods sold are recorded in
 724 C<acc_trans>.
 725
 726 =item 4. All amounts for parts, services and assemblies are recorded
 727 in C<acc_trans> with their respective charts. This is determined by
 728 the part's buchungsgruppen.
 729
 730 =item 5. The total amount is posted to the accounts receivable chart
 731 and recorded in C<acc_trans>.
 732
 733 =item 6. Items in C<invoice> are updated according to their allocation
 734 status (regarding costs of goods sold). Will only be done if
 735 kivitendo is not configured to use Einnahmenüberschussrechnungen.
 736
 737 =item 7. The invoice and its items are saved.
 738
 739 =back
 740
 741 Returns C<$self> on success and C<undef> on failure. The whole process
 742 is run inside a transaction. If it fails then nothing is saved to or
 743 changed in the database. A new transaction is only started if none are
 744 active.
 745
 746 =item C<basic_info $field>
 747
 748 See L<SL::DB::Object::basic_info>.
 749
 750 =item C<closed>
 751
 752 Returns 1 or 0, depending on whether the invoice is closed or not. Currently
 753 invoices that are overpaid also count as closed and credit notes in general.
 754
 755 =item C<recalculate_amounts %params>
 756
 757 Calculate and set amount and netamount from acc_trans objects by summing up the
 758 values of acc_trans objects with AR_amount and AR_tax link charts.
 759 amount and netamount are set to the calculated values.
 760
 761 =item C<validate_acc_trans>
 762
 763 Checks if the sum of all associated acc_trans objects is 0 and checks whether
 764 the amount of the AR acc_transaction matches the AR amount. Only the first AR
 765 line is checked, because the sum of all AR lines is 0 for paid invoices.
 766
 767 Returns 0 or 1.
 768
 769 Can be called with a debug parameter which writes debug info to STDOUT, which is
 770 useful in console mode or while writing tests.
 771
 772  my $ar = SL::DB::Manager::Invoice->get_first();
 773  $ar->validate_acc_trans(debug => 1);
 774
 775 =item C<create_ar_row %params>
 776
 777 Creates a new acc_trans entry for the receivable (AR) entry of an existing AR
 778 invoice object, which already has some income and tax acc_trans entries.
 779
 780 The acc_trans entry is also returned inside an array ref.
 781
 782 Mandatory params are
 783
 784 =over 2
 785
 786 =item * chart as an RDBO object, e.g. for bank. Must be a 'paid' chart.
 787
 788 =back
 789
 790 Currently the amount of the invoice object is used for the acc_trans amount.
 791 Use C<recalculate_amounts> before calling this method if amount isn't known
 792 yet or you didn't set it manually.
 793
 794 =item C<add_ar_amount_row %params>
 795
 796 Add a new entry for an existing AR invoice object. Creates an acc_trans entry,
 797 and also adds an acc_trans tax entry, if the tax has an associated tax chart.
 798 Also all acc_trans entries that were created are returned inside an array ref.
 799
 800 Mandatory params are
 801
 802 =over 2
 803
 804 =item * chart as an RDBO object, should be an income chart (link = AR_amount)
 805
 806 =item * tax_id
 807
 808 =item * amount
 809
 810 =back
 811
 812 =item C<mark_as_paid>
 813
 814 Marks the invoice as paid by setting its C<paid> member to the value of C<amount>.
 815
 816 =back
 817
 818 =head1 TODO
 819
 820  As explained in the new_from example, it is possible to set transdate to a new value.
 821  From a user / programm point of view transdate is more than holy and there should be
 822  some validity checker available for controller code. At least the same logic like in
 823  Form.pm from ar.pl should be available:
 824   # see old stuff ar.pl post
 825   #$form->error($locale->text('Cannot post transaction above the maximum future booking date!'))
 826   #  if ($form->date_max_future($transdate, \%myconfig));
 827   #$form->error($locale->text('Cannot post transaction for a closed period!')) if ($form->date_closed($form->{"transdate"}, \%myconfig));
 828
 829 =head1 AUTHOR
 830
 831 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
 832
 833 =cut