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   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