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