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   die "not an invoice" unless $self->invoice;
 226
 227   require SL::DB::Chart;
 228   if (!$params{ar_id}) {
 229     my $chart = SL::DB::Manager::Chart->get_all(query   => [ SL::DB::Manager::Chart->link_filter('AR') ],
 230                                                 sort_by => 'id ASC',
 231                                                 limit   => 1)->[0];
 232     croak("No AR chart found and no parameter `ar_id' given") unless $chart;
 233     $params{ar_id} = $chart->id;
 234   }
 235
 236   my $worker = sub {
 237     my %data = $self->calculate_prices_and_taxes;
 238
 239     $self->_post_create_assemblyitem_entries($data{assembly_items});
 240     $self->save;
 241
 242     $self->_post_add_acctrans($data{amounts_cogs});
 243     $self->_post_add_acctrans($data{amounts});
 244     $self->_post_add_acctrans($data{taxes});
 245
 246     $self->_post_add_acctrans({ $params{ar_id} => $self->amount * -1 });
 247
 248     $self->_post_update_allocated($data{allocated});
 249   };
 250
 251   if ($self->db->in_transaction) {
 252     $worker->();
 253   } elsif (!$self->db->do_transaction($worker)) {
 254     $::lxdebug->message(LXDebug->WARN(), "convert_to_invoice failed: " . join("\n", (split(/\n/, $self->db->error))[0..2]));
 255     return undef;
 256   }
 257
 258   return $self;
 259 }
 260
 261 sub _post_add_acctrans {
 262   my ($self, $entries) = @_;
 263
 264   my $default_tax_id = SL::DB::Manager::Tax->find_by(taxkey => 0)->id;
 265   my $chart_link;
 266
 267   require SL::DB::AccTransaction;
 268   require SL::DB::Chart;
 269   while (my ($chart_id, $spec) = each %{ $entries }) {
 270     $spec = { taxkey => 0, tax_id => $default_tax_id, amount => $spec } unless ref $spec;
 271     $chart_link = SL::DB::Manager::Chart->find_by(id => $chart_id)->{'link'};
 272     $chart_link ||= '';
 273
 274     SL::DB::AccTransaction->new(trans_id   => $self->id,
 275                                 chart_id   => $chart_id,
 276                                 amount     => $spec->{amount},
 277                                 tax_id     => $spec->{tax_id},
 278                                 taxkey     => $spec->{taxkey},
 279                                 project_id => $self->globalproject_id,
 280                                 transdate  => $self->transdate,
 281                                 chart_link => $chart_link)->save;
 282   }
 283 }
 284
 285 sub _post_create_assemblyitem_entries {
 286   my ($self, $assembly_entries) = @_;
 287
 288   my $items = $self->invoiceitems;
 289   my @new_items;
 290
 291   my $item_idx = 0;
 292   foreach my $item (@{ $items }) {
 293     next if $item->assemblyitem;
 294
 295     push @new_items, $item;
 296     $item_idx++;
 297
 298     foreach my $assembly_item (@{ $assembly_entries->[$item_idx] || [ ] }) {
 299       push @new_items, SL::DB::InvoiceItem->new(parts_id     => $assembly_item->{part},
 300                                                 description  => $assembly_item->{part}->description,
 301                                                 unit         => $assembly_item->{part}->unit,
 302                                                 qty          => $assembly_item->{qty},
 303                                                 allocated    => $assembly_item->{allocated},
 304                                                 sellprice    => 0,
 305                                                 fxsellprice  => 0,
 306                                                 assemblyitem => 't');
 307     }
 308   }
 309
 310   $self->invoiceitems(\@new_items);
 311 }
 312
 313 sub _post_update_allocated {
 314   my ($self, $allocated) = @_;
 315
 316   while (my ($invoice_id, $diff) = each %{ $allocated }) {
 317     SL::DB::Manager::InvoiceItem->update_all(set   => { allocated => { sql => "allocated + $diff" } },
 318                                              where => [ id        => $invoice_id ]);
 319   }
 320 }
 321
 322 sub invoice_type {
 323   my ($self) = @_;
 324
 325   return 'ar_transaction'     if !$self->invoice;
 326   return 'credit_note'        if $self->type eq 'credit_note' && $self->amount < 0 && !$self->storno;
 327   return 'invoice_storno'     if $self->type ne 'credit_note' && $self->amount < 0 &&  $self->storno;
 328   return 'credit_note_storno' if $self->type eq 'credit_note' && $self->amount > 0 &&  $self->storno;
 329   return 'invoice';
 330 }
 331
 332 sub displayable_state {
 333   my $self = shift;
 334
 335   return $self->closed ? $::locale->text('closed') : $::locale->text('open');
 336 }
 337
 338 sub displayable_type {
 339   my ($self) = @_;
 340
 341   return t8('AR Transaction')                         if $self->invoice_type eq 'ar_transaction';
 342   return t8('Credit Note')                            if $self->invoice_type eq 'credit_note';
 343   return t8('Invoice') . "(" . t8('Storno') . ")"     if $self->invoice_type eq 'invoice_storno';
 344   return t8('Credit Note') . "(" . t8('Storno') . ")" if $self->invoice_type eq 'credit_note_storno';
 345   return t8('Invoice');
 346 }
 347
 348 sub displayable_name {
 349   join ' ', grep $_, map $_[0]->$_, qw(displayable_type record_number);
 350 };
 351
 352 sub abbreviation {
 353   my ($self) = @_;
 354
 355   return t8('AR Transaction (abbreviation)')         if $self->invoice_type eq 'ar_transaction';
 356   return t8('Credit note (one letter abbreviation)') if $self->invoice_type eq 'credit_note';
 357   return t8('Invoice (one letter abbreviation)') . "(" . t8('Storno (one letter abbreviation)') . ")" if $self->invoice_type eq 'invoice_storno';
 358   return t8('Credit note (one letter abbreviation)') . "(" . t8('Storno (one letter abbreviation)') . ")"  if $self->invoice_type eq 'credit_note_storno';
 359   return t8('Invoice (one letter abbreviation)');
 360 }
 361
 362 sub date {
 363   goto &transdate;
 364 }
 365
 366 sub reqdate {
 367   goto &duedate;
 368 }
 369
 370 sub customervendor {
 371   goto &customer;
 372 }
 373
 374 sub link {
 375   my ($self) = @_;
 376
 377   my $html;
 378   $html   = SL::Presenter->get->sales_invoice($self, display => 'inline') if $self->invoice;
 379   $html   = SL::Presenter->get->ar_transaction($self, display => 'inline') if !$self->invoice;
 380
 381   return $html;
 382 }
 383
 384 1;
 385
 386 __END__
 387
 388 =pod
 389
 390 =head1 NAME
 391
 392 SL::DB::Invoice: Rose model for invoices (table "ar")
 393
 394 =head1 FUNCTIONS
 395
 396 =over 4
 397
 398 =item C<new_from $source, %params>
 399
 400 Creates a new C<SL::DB::Invoice> instance and copies as much
 401 information from C<$source> as possible. At the moment only sales
 402 orders and sales quotations are supported as sources.
 403
 404 The conversion copies order items into invoice items. Dates are copied
 405 as appropriate, e.g. the C<transdate> field from an order will be
 406 copied into the invoice's C<orddate> field.
 407
 408 C<%params> can include the following options:
 409
 410 =over 2
 411
 412 =item C<items>
 413
 414 An optional array reference of RDBO instances for the items to use. If
 415 missing then the method C<items_sorted> will be called on
 416 C<$source>. This option can be used to override the sorting, to
 417 exclude certain positions or to add additional ones.
 418
 419 =item C<skip_items_negative_qty>
 420
 421 If trueish then items with a negative quantity are skipped. Items with
 422 a quantity of 0 are not affected by this option.
 423
 424 =item C<skip_items_zero_qty>
 425
 426 If trueish then items with a quantity of 0 are skipped.
 427
 428 =item C<item_filter>
 429
 430 An optional code reference that is called for each item with the item
 431 as its sole parameter. Items for which the code reference returns a
 432 falsish value will be skipped.
 433
 434 =item C<attributes>
 435
 436 An optional hash reference. If it exists then it is passed to C<new>
 437 allowing the caller to set certain attributes for the new invoice.
 438 For example to set a different transdate (default is the current date),
 439 call the method like this:
 440
 441    my %params;
 442    $params{attributes}{transdate} = '28.08.2015';
 443    $invoice = SL::DB::Invoice->new_from($self, %params)->post || die;
 444
 445 =back
 446
 447 Amounts, prices and taxes are not
 448 calculated. L<SL::DB::Helper::PriceTaxCalculator::calculate_prices_and_taxes>
 449 can be used for this.
 450
 451 The object returned is not saved.
 452
 453 =item C<post %params>
 454
 455 Posts the invoice. Required parameters are:
 456
 457 =over 2
 458
 459 =item * C<ar_id>
 460
 461 The ID of the accounds receivable chart the invoices amounts are
 462 posted to. If it is not set then the first chart configured for
 463 accounts receivables is used.
 464
 465 =back
 466
 467 This function implements several steps:
 468
 469 =over 2
 470
 471 =item 1. It calculates all prices, amounts and taxes by calling
 472 L<SL::DB::Helper::PriceTaxCalculator::calculate_prices_and_taxes>.
 473
 474 =item 2. A new and unique invoice number is created.
 475
 476 =item 3. All amounts for costs of goods sold are recorded in
 477 C<acc_trans>.
 478
 479 =item 4. All amounts for parts, services and assemblies are recorded
 480 in C<acc_trans> with their respective charts. This is determined by
 481 the part's buchungsgruppen.
 482
 483 =item 5. The total amount is posted to the accounts receivable chart
 484 and recorded in C<acc_trans>.
 485
 486 =item 6. Items in C<invoice> are updated according to their allocation
 487 status (regarding for costs of goold sold). Will only be done if
 488 kivitendo is not configured to use Einnahmenüberschussrechnungen.
 489
 490 =item 7. The invoice and its items are saved.
 491
 492 =back
 493
 494 Returns C<$self> on success and C<undef> on failure. The whole process
 495 is run inside a transaction. If it fails then nothing is saved to or
 496 changed in the database. A new transaction is only started if none is
 497 active.
 498
 499 =item C<basic_info $field>
 500
 501 See L<SL::DB::Object::basic_info>.
 502
 503 =back
 504
 505 =head1 TODO
 506  As explained in the new_from example, it is possible to set transdate to a new value.
 507  From a user / programm point of view transdate is more than holy and there should be
 508  some validity checker available for controller code. At least the same logic like in
 509  Form.pm from ar.pl should be available:
 510   # see old stuff ar.pl post
 511   #$form->error($locale->text('Cannot post transaction above the maximum future booking date!'))
 512   #  if ($form->date_max_future($transdate, \%myconfig));
 513   #$form->error($locale->text('Cannot post transaction for a closed period!')) if ($form->date_closed($form->{"transdate"}, \%myconfig));
 514
 515 =head1 AUTHOR
 516
 517 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
 518
 519 =cut