Massenerstellen von RG aus LS: geschlossene LS nicht (erneut) verarbeiten
[kivitendo-erp.git] / SL / DB / Helper / PriceTaxCalculator.pm
1 package SL::DB::Helper::PriceTaxCalculator;
2
3 use strict;
4
5 use parent qw(Exporter);
6 our @EXPORT = qw(calculate_prices_and_taxes _calculate_item);
7
8 use Carp;
9 use List::Util qw(sum min max);
10
11 sub calculate_prices_and_taxes {
12   my ($self, %params) = @_;
13
14   require SL::DB::Chart;
15   require SL::DB::Currency;
16   require SL::DB::Default;
17   require SL::DB::InvoiceItem;
18   require SL::DB::Part;
19   require SL::DB::PriceFactor;
20   require SL::DB::Unit;
21
22   SL::DB::Part->load_cached(map { $_->parts_id } @{ $self->items }) if @{ $self->items || [] };
23
24   my %units_by_name       = map { ( $_->name => $_ ) } @{ SL::DB::Manager::Unit->get_all        };
25   my %price_factors_by_id = map { ( $_->id   => $_ ) } @{ SL::DB::Manager::PriceFactor->get_all };
26
27   my %data = ( lastcost_total      => 0,
28                invoicediff         => 0,
29                last_incex_chart_id => undef,
30                units_by_name       => \%units_by_name,
31                price_factors_by_id => \%price_factors_by_id,
32                taxes_by_chart_id   => { },
33                taxes_by_tax_id     => { },
34                amounts             => { },
35                amounts_cogs        => { },
36                allocated           => { },
37                assembly_items      => [ ],
38                exchangerate        => undef,
39                is_sales            => $self->can('customer') && $self->customer,
40                is_invoice          => (ref($self) =~ /Invoice/) || $params{invoice},
41                items               => [ ],
42              );
43
44   # set exchangerate in $data>{exchangerate}
45   if ( ref($self) eq 'SL::DB::Order' ) {
46     # orders store amount in the order currency
47     $data{exchangerate} = 1;
48   } else {
49     # invoices store amount in the default currency
50     _get_exchangerate($self, \%data, %params);
51     # $data{exchangerate} = $self->exchangerate; # untested alternative for setting exchangerate
52   };
53
54   $self->netamount(  0);
55   $self->marge_total(0);
56
57   SL::DB::Manager::Chart->cache_taxkeys(date => $self->deliverydate // $self->transdate);
58
59   my $idx = 0;
60   foreach my $item (@{ $self->items_sorted }) {
61     $idx++;
62     _calculate_item($self, $item, $idx, \%data, %params);
63   }
64
65   _calculate_amounts($self, \%data, %params);
66
67   return $self unless wantarray;
68
69   return map { ($_ => $data{$_}) } qw(taxes_by_chart_id taxes_by_tax_id amounts amounts_cogs allocated exchangerate assembly_items items rounding);
70 }
71
72 sub _get_exchangerate {
73   my ($self, $data, %params) = @_;
74
75   my $currency = $self->currency_id ? SL::DB::Currency->load_cached($self->currency_id)->name || '' : '';
76   if ($currency ne SL::DB::Default->get_default_currency) {
77     $data->{exchangerate}   = $::form->check_exchangerate(\%::myconfig, $currency, $self->transdate, $data->{is_sales} ? 'buy' : 'sell');
78     $data->{exchangerate} ||= $params{exchangerate};
79   }
80   $data->{exchangerate} ||= 1;
81 }
82
83 sub _calculate_item {
84   my ($self, $item, $idx, $data, %params) = @_;
85
86   my $part       = SL::DB::Part->load_cached($item->parts_id);
87   return unless $part;
88
89   my $part_unit  = $data->{units_by_name}->{ $part->unit };
90   my $item_unit  = $data->{units_by_name}->{ $item->unit };
91
92   croak("Undefined unit " . $part->unit) if !$part_unit;
93   croak("Undefined unit " . $item->unit) if !$item_unit;
94
95   $item->base_qty($item_unit->convert_to($item->qty, $part_unit));
96   $item->fxsellprice($item->sellprice) if $data->{is_invoice};
97
98   my $num_dec   = max 2, _num_decimal_places($item->sellprice);
99
100   $item->discount(0) if !$item->discount;
101
102   # don't include rounded discount into sellprice for calculation
103   # any time the sellprice is multiplied with qty discount has to be considered as part of the multiplication
104   my $sellprice = $item->sellprice;
105
106   $item->price_factor(      ! $item->price_factor_obj   ? 1 : ($item->price_factor_obj->factor   || 1));
107   $item->marge_price_factor(! $part->price_factor ? 1 : ($part->price_factor->factor || 1));
108   my $linetotal = _round($sellprice * (1 - $item->discount) * $item->qty / $item->price_factor, 2) * $data->{exchangerate};
109   $linetotal    = _round($linetotal,                                                            2);
110
111   $data->{invoicediff} += $sellprice * (1 - $item->discount) * $item->qty * $data->{exchangerate} / $item->price_factor - $linetotal if $self->taxincluded;
112
113   my $taxkey     = $part->get_taxkey(date => $self->deliverydate // $self->transdate, is_sales => $data->{is_sales}, taxzone => $self->taxzone_id);
114   my $tax_rate   = $taxkey->tax->rate;
115   my $tax_amount = undef;
116
117   if ($self->taxincluded) {
118     $tax_amount = $linetotal * $tax_rate / ($tax_rate + 1);
119     $sellprice  = $sellprice             / ($tax_rate + 1);
120
121   } else {
122     $tax_amount = $linetotal * $tax_rate;
123   }
124
125   if ($taxkey->tax->chart_id) {
126     $data->{taxes_by_chart_id}->{ $taxkey->tax->chart_id } ||= 0;
127     $data->{taxes_by_chart_id}->{ $taxkey->tax->chart_id }  += $tax_amount;
128     $data->{taxes_by_tax_id}->{ $taxkey->tax_id }          ||= 0;
129     $data->{taxes_by_tax_id}->{ $taxkey->tax_id }           += $tax_amount;
130   } elsif ($tax_amount) {
131     die "tax_amount != 0 but no chart_id for taxkey " . $taxkey->id . " tax " . $taxkey->tax->id;
132   }
133
134   my $chart = $part->get_chart(type => $data->{is_sales} ? 'income' : 'expense', taxzone => $self->taxzone_id);
135   $data->{amounts}->{ $chart->id }           ||= { taxkey => $taxkey->taxkey_id, tax_id => $taxkey->tax_id, amount => 0 };
136   $data->{amounts}->{ $chart->id }->{amount}  += $linetotal;
137   $data->{amounts}->{ $chart->id }->{amount}  -= $tax_amount if $self->taxincluded;
138
139   my $linetotal_cost = 0;
140
141   if (!$linetotal) {
142     $item->marge_total(  0);
143     $item->marge_percent(0);
144
145   } else {
146     my $lastcost       = !(($item->lastcost // 0) * 1) ? ($part->lastcost || 0) : $item->lastcost;
147     $linetotal_cost    = _round($lastcost * $item->qty / $item->marge_price_factor, 2);
148     my $linetotal_net  = $self->taxincluded ? $linetotal - $tax_amount : $linetotal;
149
150     $item->marge_total(  $linetotal_net - $linetotal_cost);
151     $item->marge_percent($item->marge_total * 100 / $linetotal_net);
152
153     $self->marge_total(  $self->marge_total + $item->marge_total);
154     $data->{lastcost_total} += $linetotal_cost;
155   }
156
157   push @{ $data->{assembly_items} }, [];
158   if ($part->is_assembly) {
159     _calculate_assembly_item($self, $data, $part, $item->base_qty, $item_unit->convert_to(1, $part_unit));
160   } elsif ($part->is_part) {
161     if ($data->{is_invoice}) {
162       $item->allocated(_calculate_part_item($self, $data, $part, $item->base_qty, $item_unit->convert_to(1, $part_unit)));
163     }
164   }
165
166   $data->{last_incex_chart_id} = $chart->id if $data->{is_sales};
167
168   my $item_sellprice = _round($sellprice * (1 - $item->discount), $num_dec);
169
170   push @{ $data->{items} }, {
171     linetotal      => $linetotal,
172     linetotal_cost => $linetotal_cost,
173     sellprice      => $item_sellprice,
174     tax_amount     => $tax_amount,
175     taxkey_id      => $taxkey->id,
176   };
177
178   _dbg("CALCULATE! ${idx} i.qty " . $item->qty . " i.sellprice " . $item->sellprice . " sellprice $sellprice num_dec $num_dec taxamount $tax_amount " .
179        "i.linetotal $linetotal netamount " . $self->netamount . " marge_total " . $item->marge_total . " marge_percent " . $item->marge_percent);
180 }
181
182 sub _calculate_amounts {
183   my ($self, $data, %params) = @_;
184
185   my $tax_diff = 0;
186   foreach my $chart_id (keys %{ $data->{taxes_by_chart_id} }) {
187     my $rounded                              = _round($data->{taxes_by_chart_id}->{$chart_id} * $data->{exchangerate}, 2);
188     $tax_diff                               += $data->{taxes_by_chart_id}->{$chart_id} * $data->{exchangerate} - $rounded if $self->taxincluded;
189     $data->{taxes_by_chart_id}->{$chart_id}  = $rounded;
190   }
191
192   $self->netamount(sum map { $_->{amount} } values %{ $data->{amounts} });
193
194   my $amount    = _round(($self->netamount + $tax_diff) * $data->{exchangerate}, 2);
195   my $diff      = $amount - ($self->netamount + $tax_diff) * $data->{exchangerate};
196   my $netamount = $amount;
197
198   if ($self->taxincluded) {
199     $data->{invoicediff}                                         += $diff;
200     $data->{amounts}->{ $data->{last_incex_chart_id} }->{amount} += $data->{invoicediff} if $data->{last_incex_chart_id};
201   }
202
203   _dbg("Sna " . $self->netamount . " idiff " . $data->{invoicediff} . " tdiff ${tax_diff}");
204
205   my $tax              = sum values %{ $data->{taxes_by_chart_id} };
206   $amount              = $netamount + $tax;
207   my $grossamount      = _round($amount, 2, 1);
208   $data->{rounding}    = _round($grossamount - $amount, 2);
209   $data->{arap_amount} = $grossamount;
210
211   $self->netamount(    $netamount);
212   $self->amount(       $grossamount);
213   $self->marge_percent($self->netamount ? ($self->netamount - $data->{lastcost_total}) * 100 / $self->netamount : 0);
214 }
215
216 sub _calculate_assembly_item {
217   my ($self, $data, $part, $total_qty, $base_factor) = @_;
218
219   return 0 if $::instance_conf->get_inventory_system eq 'periodic' || !$data->{is_invoice};
220
221   foreach my $assembly_entry (@{ $part->assemblies }) {
222     push @{ $data->{assembly_items}->[-1] }, { part      => $assembly_entry->part,
223                                                qty       => $total_qty * $assembly_entry->qty,
224                                                allocated => 0 };
225
226     if ($assembly_entry->part->is_assembly) {
227       _calculate_assembly_item($self, $data, $assembly_entry->part, $total_qty * $assembly_entry->qty);
228     } elsif ($assembly_entry->part->is_part) {
229       my $allocated = _calculate_part_item($self, $data, $assembly_entry->part, $total_qty * $assembly_entry->qty);
230       $data->{assembly_items}->[-1]->[-1]->{allocated} = $allocated;
231     }
232   }
233 }
234
235 sub _calculate_part_item {
236   my ($self, $data, $part, $total_qty, $base_factor) = @_;
237
238   _dbg("cpsi tq " . $total_qty);
239
240   return 0 if $::instance_conf->get_inventory_system eq 'periodic' || !$data->{is_invoice} || !$total_qty;
241
242   my ($entry);
243   $base_factor           ||= 1;
244   my $remaining_qty        = $total_qty;
245   my $expense_income_chart = $part->get_chart(type => $data->{is_sales} ? 'expense' : 'income', taxzone => $self->taxzone_id);
246   my $inventory_chart      = $part->get_chart(type => 'inventory',                              taxzone => $self->taxzone_id);
247
248   my $iterator             = SL::DB::Manager::InvoiceItem->get_all_iterator(query => [ and => [ parts_id => $part->id,
249                                                                                                 \'(base_qty + allocated) < 0' ] ]);
250
251   while (($remaining_qty > 0) && ($entry = $iterator->next)) {
252     my $qty = min($remaining_qty, $entry->base_qty * -1 - $entry->allocated - $data->{allocated}->{ $entry->id });
253     _dbg("qty $qty");
254
255     next unless $qty;
256
257     my $linetotal = _round(($entry->sellprice * (1 - $entry->discount) * $qty) / $base_factor, 2);
258
259     $data->{amounts_cogs}->{ $expense_income_chart->id } -= $linetotal;
260     $data->{amounts_cogs}->{ $inventory_chart->id      } += $linetotal;
261
262     $data->{allocated}->{ $entry->id } ||= 0;
263     $data->{allocated}->{ $entry->id }  += $qty;
264     $remaining_qty                      -= $qty;
265   }
266
267   $iterator->finish;
268
269   return $remaining_qty - $total_qty;
270 }
271
272 sub _round {
273   return $::form->round_amount(@_);
274 }
275
276 sub _num_decimal_places {
277   return length( (split(/\./, '' . ($_[0] * 1), 2))[1] || '' );
278 }
279
280 sub _dbg {
281   # $::lxdebug->message(0, join(' ', @_));
282 }
283
284 1;
285 __END__
286
287 =pod
288
289 =encoding utf8
290
291 =head1 NAME
292
293 SL::DB::Helper::PriceTaxCalculator - Mixin for calculating the prices,
294 amounts and taxes of orders, quotations, invoices
295
296 =head1 FUNCTIONS
297
298 =over 4
299
300 =item C<calculate_prices_and_taxes %params>
301
302 Calculates the prices, amounts and taxes for an order, a quotation or
303 an invoice.
304
305 The function assumes that the mixing package has a certain layout and
306 provides certain functions:
307
308 =over 2
309
310 =item C<transdate>
311
312 The record's date.
313
314 =item C<customer> or C<vendor>
315
316 Determines if the record is a sales or purchase record.
317
318 =item C<items>
319
320 Accessor returning all line items for this record. The line items
321 themselves must again have a certain layout. Instances of
322 L<SL::DB::OrderItem> and L<SL::DB::InvoiceItem> are supported.
323
324 =back
325
326 The following values are calculated and set for C<$self>: C<amount>,
327 C<netamount>, C<marge_percent>, C<marge_total>.
328
329 The following values are calculated and set for each line item:
330 C<base_qty>, C<price_factor>, C<marge_price_factor>, C<marge_total>,
331 C<marge_percent>.
332
333 The objects are not saved.
334
335 Returns C<$self> in scalar context.
336
337 In array context a hash with the following keys is returned:
338
339 =over 2
340
341 =item C<taxes_by_chart_id>
342
343 A hash reference with the calculated taxes. The keys are chart IDs,
344 the values the rounded calculated taxes.
345
346 =item C<taxes_by_tax_id>
347
348 A hash reference with the calculated taxes. The keys are tax IDs,
349 the values the calculated taxes.
350
351 =item C<amounts>
352
353 A hash reference with the calculated amounts. The keys are chart IDs,
354 the values are hash references containing the two keys C<amount> and
355 C<taxkey>.
356
357 =item C<amounts_cogs>
358
359 A hash reference with the calculated amounts for costs of goods
360 sold. The keys are chart IDs, the values the calculated amounts.
361
362 =item C<assembly_items>
363
364 An array reference with as many entries as there are items in the
365 record. Each entry is again an array reference of hash references with
366 the keys C<part> (an instance of L<SL::DB::Part>), C<qty> and
367 C<allocated>. Is only valid for invoices and can be used to populate
368 the C<invoice> table with entries for assemblies.
369
370 =item C<allocated>
371
372 A hash reference. The keys are IDs of entries in the C<invoice>
373 table. The values are the new values for the entry's C<allocated>
374 column. Only valid for invoices.
375
376 =item C<exchangerate>
377
378 The exchangerate used for the calculation.
379
380 =item C<items>
381
382 An array reference. For each line item this array contains a hash ref
383 entry with additional values that have been calculated for that item
384 but that aren't stored in the item object itself. These include
385 C<linetotal>, C<linetotal_cost>, C<sellprice>, C<tax_amount> and
386 C<taxkey_id>.
387
388 The items are stored in the same order the items are stored in the
389 object that L</calculate_prices_and_taxes> has been called on.
390
391 For example:
392
393   my $invoice     = SL::DB::Invoice->new(id => 12345)->load;
394   my %data        = $invoice->calculate_prices_and_taxes;
395
396   print "line total of second item: " . $data{items}->[1]->{linetotal};
397
398 =back
399
400 =back
401
402 =head1 BUGS
403
404 Nothing here yet.
405
406 =head1 AUTHOR
407
408 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
409
410 =cut