SL/DB/Invoice.pm

   1 package SL::DB::Invoice;
   2
   3 use strict;
   4
   5 use Carp;
   6 use List::Util qw(first);
   7
   8 use Rose::DB::Object::Helpers ();
   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 );
  64
  65 __PACKAGE__->meta->initialize;
  66
  67 __PACKAGE__->attr_html('notes');
  68 __PACKAGE__->attr_sorted('items');
  69
  70 __PACKAGE__->before_save('_before_save_set_invnumber');
  71
  72 # hooks
  73
  74 sub _before_save_set_invnumber {
  75   my ($self) = @_;
  76
  77   $self->create_trans_number if !$self->invnumber;
  78
  79   return 1;
  80 }
  81
  82 # methods
  83
  84 sub items { goto &invoiceitems; }
  85 sub add_items { goto &add_invoiceitems; }
  86 sub record_number { goto &invnumber; };
  87
  88 sub is_sales {
  89   # For compatibility with Order, DeliveryOrder
  90   croak 'not an accessor' if @_ > 1;
  91   return 1;
  92 }
  93
  94 # it is assumed, that ordnumbers are unique here.
  95 sub first_order_by_ordnumber {
  96   my $self = shift;
  97
  98   my $orders = SL::DB::Manager::Order->get_all(
  99     query => [
 100       ordnumber => $self->ordnumber,
 101
 102     ],
 103   );
 104
 105   return first { $_->is_type('sales_order') } @{ $orders };
 106 }
 107
 108 sub abschlag_percentage {
 109   my $self         = shift;
 110   my $order        = $self->first_order_by_ordnumber or return;
 111   my $order_amount = $order->netamount               or return;
 112   return $self->abschlag
 113     ? $self->netamount / $order_amount
 114     : undef;
 115 }
 116
 117 sub taxamount {
 118   my $self = shift;
 119   die 'not a setter method' if @_;
 120
 121   return ($self->amount || 0) - ($self->netamount || 0);
 122 }
 123
 124 __PACKAGE__->meta->make_attr_helpers(taxamount => 'numeric(15,5)');
 125
 126 sub closed {
 127   my ($self) = @_;
 128   return $self->paid >= $self->amount;
 129 }
 130
 131 sub _clone_orderitem_delivery_order_item_cvar {
 132   my ($cvar) = @_;
 133
 134   my $cloned = Rose::DB::Object::Helpers::clone_and_reset($_);
 135   $cloned->sub_module('invoice');
 136
 137   return $cloned;
 138 }
 139
 140 sub new_from {
 141   my ($class, $source, %params) = @_;
 142
 143   croak("Unsupported source object type '" . ref($source) . "'") unless ref($source) =~ m/^ SL::DB:: (?: Order | DeliveryOrder ) $/x;
 144   croak("Cannot create invoices for purchase records")           unless $source->customer_id;
 145
 146   require SL::DB::Employee;
 147
 148   my (@columns, @item_columns, $item_parent_id_column, $item_parent_column);
 149
 150   if (ref($source) eq 'SL::DB::Order') {
 151     @columns      = qw(quonumber delivery_customer_id delivery_vendor_id);
 152     @item_columns = qw(subtotal);
 153
 154     $item_parent_id_column = 'trans_id';
 155     $item_parent_column    = 'order';
 156
 157   } else {
 158     @columns      = qw(donumber);
 159
 160     $item_parent_id_column = 'delivery_order_id';
 161     $item_parent_column    = 'delivery_order';
 162   }
 163
 164   my $terms = $source->can('payment_id') ? $source->payment_terms : undef;
 165
 166   my %args = ( map({ ( $_ => $source->$_ ) } qw(customer_id taxincluded shippingpoint shipvia notes intnotes salesman_id cusordnumber ordnumber department_id
 167                                                 cp_id language_id taxzone_id shipto_id globalproject_id transaction_description currency_id delivery_term_id payment_id), @columns),
 168                transdate   => DateTime->today_local,
 169                gldate      => DateTime->today_local,
 170                duedate     => $terms ? $terms->calc_date(reference_date => DateTime->today_local) : DateTime->today_local,
 171                invoice     => 1,
 172                type        => 'invoice',
 173                storno      => 0,
 174                paid        => 0,
 175                employee_id => (SL::DB::Manager::Employee->current || SL::DB::Employee->new(id => $source->employee_id))->id,
 176             );
 177
 178   if ($source->type =~ /_order$/) {
 179     $args{deliverydate} = $source->reqdate;
 180     $args{orddate}      = $source->transdate;
 181   } else {
 182     $args{quodate}      = $source->transdate;
 183   }
 184
 185   my $invoice = $class->new(%args);
 186   $invoice->assign_attributes(%{ $params{attributes} }) if $params{attributes};
 187   my $items   = delete($params{items}) || $source->items_sorted;
 188   my %item_parents;
 189
 190   my @items = map {
 191     my $source_item      = $_;
 192     my $source_item_id   = $_->$item_parent_id_column;
 193     my @custom_variables = map { _clone_orderitem_delivery_order_item_cvar($_) } @{ $source_item->custom_variables };
 194
 195     $item_parents{$source_item_id} ||= $source_item->$item_parent_column;
 196     my $item_parent                  = $item_parents{$source_item_id};
 197     my $current_invoice_item =
 198       SL::DB::InvoiceItem->new(map({ ( $_ => $source_item->$_ ) }
 199                                    qw(parts_id description qty sellprice discount project_id serialnumber pricegroup_id transdate cusordnumber unit
 200                                       base_qty longdescription lastcost price_factor_id active_discount_source active_price_source), @item_columns),
 201                                deliverydate     => $source_item->reqdate,
 202                                fxsellprice      => $source_item->sellprice,
 203                                custom_variables => \@custom_variables,
 204                                ordnumber        => ref($item_parent) eq 'SL::DB::Order'         ? $item_parent->ordnumber : $source_item->ordnumber,
 205                                donumber         => ref($item_parent) eq 'SL::DB::DeliveryOrder' ? $item_parent->donumber  : $source_item->can('donumber') ? $source_item->donumber : '',
 206                              );
 207
 208     $current_invoice_item->{"converted_from_orderitems_id"}           = $_->{id} if ref($item_parent) eq 'SL::DB::Order';
 209     $current_invoice_item->{"converted_from_delivery_order_items_id"} = $_->{id} if ref($item_parent) eq 'SL::DB::DeliveryOrder';
 210     $current_invoice_item;
 211   } @{ $items };
 212
 213   @items = grep { $params{item_filter}->($_) } @items if $params{item_filter};
 214   @items = grep { $_->qty * 1 } @items if $params{skip_items_zero_qty};
 215   @items = grep { $_->qty >=0 } @items if $params{skip_items_negative_qty};
 216
 217   $invoice->invoiceitems(\@items);
 218
 219   return $invoice;
 220 }
 221
 222 sub post {
 223   my ($self, %params) = @_;
 224
 225   require SL::DB::Chart;
 226   if (!$params{ar_id}) {
 227     my $chart = SL::DB::Manager::Chart->get_all(query   => [ SL::DB::Manager::Chart->link_filter('AR') ],
 228                                                 sort_by => 'id ASC',
 229                                                 limit   => 1)->[0];
 230     croak("No AR chart found and no parameter `ar_id' given") unless $chart;
 231     $params{ar_id} = $chart->id;
 232   }
 233
 234   my $worker = sub {
 235     my %data = $self->calculate_prices_and_taxes;
 236
 237     $self->_post_create_assemblyitem_entries($data{assembly_items});
 238     $self->save;
 239
 240     $self->_post_add_acctrans($data{amounts_cogs});
 241     $self->_post_add_acctrans($data{amounts});
 242     $self->_post_add_acctrans($data{taxes});
 243
 244     $self->_post_add_acctrans({ $params{ar_id} => $self->amount * -1 });
 245
 246     $self->_post_update_allocated($data{allocated});
 247   };
 248
 249   if ($self->db->in_transaction) {
 250     $worker->();
 251   } elsif (!$self->db->do_transaction($worker)) {
 252     $::lxdebug->message(LXDebug->WARN(), "convert_to_invoice failed: " . join("\n", (split(/\n/, $self->db->error))[0..2]));
 253     return undef;
 254   }
 255
 256   return $self;
 257 }
 258
 259 sub _post_add_acctrans {
 260   my ($self, $entries) = @_;
 261
 262   my $default_tax_id = SL::DB::Manager::Tax->find_by(taxkey => 0)->id;
 263   my $chart_link;
 264
 265   require SL::DB::AccTransaction;
 266   require SL::DB::Chart;
 267   while (my ($chart_id, $spec) = each %{ $entries }) {
 268     $spec = { taxkey => 0, tax_id => $default_tax_id, amount => $spec } unless ref $spec;
 269     $chart_link = SL::DB::Manager::Chart->find_by(id => $chart_id)->{'link'};
 270     $chart_link ||= '';
 271
 272     SL::DB::AccTransaction->new(trans_id   => $self->id,
 273                                 chart_id   => $chart_id,
 274                                 amount     => $spec->{amount},
 275                                 tax_id     => $spec->{tax_id},
 276                                 taxkey     => $spec->{taxkey},
 277                                 project_id => $self->globalproject_id,
 278                                 transdate  => $self->transdate,
 279                                 chart_link => $chart_link)->save;
 280   }
 281 }
 282
 283 sub _post_create_assemblyitem_entries {
 284   my ($self, $assembly_entries) = @_;
 285
 286   my $items = $self->invoiceitems;
 287   my @new_items;
 288
 289   my $item_idx = 0;
 290   foreach my $item (@{ $items }) {
 291     next if $item->assemblyitem;
 292
 293     push @new_items, $item;
 294     $item_idx++;
 295
 296     foreach my $assembly_item (@{ $assembly_entries->[$item_idx] || [ ] }) {
 297       push @new_items, SL::DB::InvoiceItem->new(parts_id     => $assembly_item->{part},
 298                                                 description  => $assembly_item->{part}->description,
 299                                                 unit         => $assembly_item->{part}->unit,
 300                                                 qty          => $assembly_item->{qty},
 301                                                 allocated    => $assembly_item->{allocated},
 302                                                 sellprice    => 0,
 303                                                 fxsellprice  => 0,
 304                                                 assemblyitem => 't');
 305     }
 306   }
 307
 308   $self->invoiceitems(\@new_items);
 309 }
 310
 311 sub _post_update_allocated {
 312   my ($self, $allocated) = @_;
 313
 314   while (my ($invoice_id, $diff) = each %{ $allocated }) {
 315     SL::DB::Manager::InvoiceItem->update_all(set   => { allocated => { sql => "allocated + $diff" } },
 316                                              where => [ id        => $invoice_id ]);
 317   }
 318 }
 319
 320 sub invoice_type {
 321   my ($self) = @_;
 322
 323   return 'ar_transaction'     if !$self->invoice;
 324   return 'credit_note'        if $self->type eq 'credit_note' && $self->amount < 0 && !$self->storno;
 325   return 'invoice_storno'     if $self->type ne 'credit_note' && $self->amount < 0 &&  $self->storno;
 326   return 'credit_note_storno' if $self->type eq 'credit_note' && $self->amount > 0 &&  $self->storno;
 327   return 'invoice';
 328 }
 329
 330 sub displayable_state {
 331   my $self = shift;
 332
 333   return $self->closed ? $::locale->text('closed') : $::locale->text('open');
 334 }
 335
 336 sub displayable_type {
 337   my ($self) = @_;
 338
 339   return t8('AR Transaction')                         if $self->invoice_type eq 'ar_transaction';
 340   return t8('Credit Note')                            if $self->invoice_type eq 'credit_note';
 341   return t8('Invoice') . "(" . t8('Storno') . ")"     if $self->invoice_type eq 'invoice_storno';
 342   return t8('Credit Note') . "(" . t8('Storno') . ")" if $self->invoice_type eq 'credit_note_storno';
 343   return t8('Invoice');
 344 }
 345
 346 sub displayable_name {
 347   join ' ', grep $_, map $_[0]->$_, qw(displayable_type record_number);
 348 };
 349
 350 sub abbreviation {
 351   my ($self) = @_;
 352
 353   return t8('AR Transaction (abbreviation)')         if $self->invoice_type eq 'ar_transaction';
 354   return t8('Credit note (one letter abbreviation)') if $self->invoice_type eq 'credit_note';
 355   return t8('Invoice (one letter abbreviation)') . "(" . t8('Storno (one letter abbreviation)') . ")" if $self->invoice_type eq 'invoice_storno';
 356   return t8('Credit note (one letter abbreviation)') . "(" . t8('Storno (one letter abbreviation)') . ")"  if $self->invoice_type eq 'credit_note_storno';
 357   return t8('Invoice (one letter abbreviation)');
 358 }
 359
 360 sub date {
 361   goto &transdate;
 362 }
 363
 364 sub reqdate {
 365   goto &duedate;
 366 }
 367
 368 sub customervendor {
 369   goto &customer;
 370 }
 371
 372 sub link {
 373   my ($self) = @_;
 374
 375   my $html;
 376   $html   = SL::Presenter->get->sales_invoice($self, display => 'inline') if $self->invoice;
 377   $html   = SL::Presenter->get->ar_transaction($self, display => 'inline') if !$self->invoice;
 378
 379   return $html;
 380 }
 381
 382 1;
 383
 384 __END__
 385
 386 =pod
 387
 388 =head1 NAME
 389
 390 SL::DB::Invoice: Rose model for invoices (table "ar")
 391
 392 =head1 FUNCTIONS
 393
 394 =over 4
 395
 396 =item C<new_from $source, %params>
 397
 398 Creates a new C<SL::DB::Invoice> instance and copies as much
 399 information from C<$source> as possible. At the moment only sales
 400 orders and sales quotations are supported as sources.
 401
 402 The conversion copies order items into invoice items. Dates are copied
 403 as appropriate, e.g. the C<transdate> field from an order will be
 404 copied into the invoice's C<orddate> field.
 405
 406 C<%params> can include the following options:
 407
 408 =over 2
 409
 410 =item C<items>
 411
 412 An optional array reference of RDBO instances for the items to use. If
 413 missing then the method C<items_sorted> will be called on
 414 C<$source>. This option can be used to override the sorting, to
 415 exclude certain positions or to add additional ones.
 416
 417 =item C<skip_items_negative_qty>
 418
 419 If trueish then items with a negative quantity are skipped. Items with
 420 a quantity of 0 are not affected by this option.
 421
 422 =item C<skip_items_zero_qty>
 423
 424 If trueish then items with a quantity of 0 are skipped.
 425
 426 =item C<item_filter>
 427
 428 An optional code reference that is called for each item with the item
 429 as its sole parameter. Items for which the code reference returns a
 430 falsish value will be skipped.
 431
 432 =item C<attributes>
 433
 434 An optional hash reference. If it exists then it is passed to C<new>
 435 allowing the caller to set certain attributes for the new invoice.
 436 For example to set a different transdate (default is the current date),
 437 call the method like this:
 438
 439    my %params;
 440    $params{attributes}{transdate} = '28.08.2015';
 441    $invoice = SL::DB::Invoice->new_from($self, %params)->post || die;
 442
 443 =back
 444
 445 Amounts, prices and taxes are not
 446 calculated. L<SL::DB::Helper::PriceTaxCalculator::calculate_prices_and_taxes>
 447 can be used for this.
 448
 449 The object returned is not saved.
 450
 451 =item C<post %params>
 452
 453 Posts the invoice. Required parameters are:
 454
 455 =over 2
 456
 457 =item * C<ar_id>
 458
 459 The ID of the accounds receivable chart the invoices amounts are
 460 posted to. If it is not set then the first chart configured for
 461 accounts receivables is used.
 462
 463 =back
 464
 465 This function implements several steps:
 466
 467 =over 2
 468
 469 =item 1. It calculates all prices, amounts and taxes by calling
 470 L<SL::DB::Helper::PriceTaxCalculator::calculate_prices_and_taxes>.
 471
 472 =item 2. A new and unique invoice number is created.
 473
 474 =item 3. All amounts for costs of goods sold are recorded in
 475 C<acc_trans>.
 476
 477 =item 4. All amounts for parts, services and assemblies are recorded
 478 in C<acc_trans> with their respective charts. This is determined by
 479 the part's buchungsgruppen.
 480
 481 =item 5. The total amount is posted to the accounts receivable chart
 482 and recorded in C<acc_trans>.
 483
 484 =item 6. Items in C<invoice> are updated according to their allocation
 485 status (regarding for costs of goold sold). Will only be done if
 486 kivitendo is not configured to use Einnahmenüberschussrechnungen.
 487
 488 =item 7. The invoice and its items are saved.
 489
 490 =back
 491
 492 Returns C<$self> on success and C<undef> on failure. The whole process
 493 is run inside a transaction. If it fails then nothing is saved to or
 494 changed in the database. A new transaction is only started if none is
 495 active.
 496
 497 =item C<basic_info $field>
 498
 499 See L<SL::DB::Object::basic_info>.
 500
 501 =back
 502
 503 =head1 TODO
 504  As explained in the new_from example, it is possible to set transdate to a new value.
 505  From a user / programm point of view transdate is more than holy and there should be
 506  some validity checker available for controller code. At least the same logic like in
 507  Form.pm from ar.pl should be available:
 508   # see old stuff ar.pl post
 509   #$form->error($locale->text('Cannot post transaction above the maximum future booking date!'))
 510   #  if ($form->date_max_future($transdate, \%myconfig));
 511   #$form->error($locale->text('Cannot post transaction for a closed period!')) if ($form->date_closed($form->{"transdate"}, \%myconfig));
 512
 513 =head1 AUTHOR
 514
 515 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
 516
 517 =cut