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