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