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