Invoice.pm

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