projekt kivitendo

               last_incex_chart_id => undef,

  _calculate_amounts($self, \%data, %params);

  $data->{invoicediff} += $sellprice * $item->qty * $data->{exchangerate} / $item->price_factor - $linetotal if $self->taxincluded;

  $data->{amounts}->{ $chart->id }           ||= { taxkey => $taxkey->id, amount => 0 };

  $data->{amounts}->{ $chart->id }->{amount}  += $linetotal;

  if ($item->part->is_assembly) {

    _calculate_assembly_item($self, $data, $item->part, $item->base_qty, $item->unit_obj->convert_to(1, $item->part->unit_obj));

  } elsif ($item->part->is_part) {

    $item->allocated(_calculate_part_item($self, $data, $item->part, $item->base_qty, $item->unit_obj->convert_to(1, $item->part->unit_obj)));

  }

  $data->{last_incex_chart_id} = $chart->id if $data->{is_sales};

  _dbg("CALCULATE! ${idx} i.qty " . $item->qty . " i.sellprice " . $item->sellprice . " sellprice $sellprice num_dec $num_dec taxamount $tax_amount " .

       "i.linetotal $linetotal netamount " . $self->netamount . " marge_total " . $item->marge_total . " marge_percent " . $item->marge_percent);

sub _calculate_amounts {

  my $tax_diff = 0;

  foreach my $chart_id (keys %{ $data->{taxes} }) {

    my $rounded                  = _round($data->{taxes}->{$chart_id} * $data->{exchangerate}, 2);

    $tax_diff                   += $data->{taxes}->{$chart_id} * $data->{exchangerate} - $rounded if $self->taxincluded;

    $data->{taxes}->{$chart_id}  = $rounded;

  }

  my $amount    = _round(($self->netamount + $tax_diff) * $data->{exchangerate}, 2);

  my $diff      = $amount - ($self->netamount + $tax_diff) * $data->{exchangerate};

  my $netamount = $amount;

  if ($self->taxincluded) {

    $data->{invoicediff}                                         += $diff;

    $data->{amounts}->{ $data->{last_incex_chart_id} }->{amount} += $data->{invoicediff} if $data->{last_incex_chart_id};

  }

  _dbg("Sna " . $self->netamount . " idiff " . $data->{invoicediff} . " tdiff ${tax_diff}");

  my $tax              = sum values %{ $data->{taxes} };

  $data->{arap_amount} = $netamount + $tax;

  $self->netamount(    $netamount);

  $self->amount(       $netamount + $tax);

  $self->marge_percent($self->netamount ? ($self->netamount - $data->{lastcost_total}) * 100 / $self->netamount : 0);

    push @{ $data->{assembly_items}->[-1] }, { part      => $assembly_entry->part,

                                               qty       => $total_qty * $assembly_entry->qty,

                                               allocated => 0 };

    if ($assembly_entry->part->is_assembly) {

      _calculate_assembly_item($self, $data, $assembly_entry->part, $total_qty * $assembly_entry->qty);

    } elsif ($assembly_entry->part->is_part) {

      my $allocated = _calculate_part_item($self, $data, $assembly_entry->part, $total_qty * $assembly_entry->qty);

      $data->{assembly_items}->[-1]->[-1]->{allocated} = $allocated;

    }

sub _calculate_part_item {

  _dbg("cpsi tq " . $total_qty);

    my $qty = min($remaining_qty, $entry->base_qty * -1 - $entry->allocated - $data->{allocated}->{ $entry->id });

    _dbg("qty $qty");

    $data->{allocated}->{ $entry->id } ||= 0;

    $data->{allocated}->{ $entry->id }  += $qty;

    $remaining_qty                      -= $qty;

  return length( (split(/\./, '' . ($_[0] * 1), 2))[1] || '' );

}

sub _dbg {

  $::lxdebug->message(0, join(' ', @_));

an invoice.

The function assumes that the mixing package has a certain layout and

provides certain functions:

the values are hash references containing the two keys C<amount> and

C<taxkey>.

=item C<amounts_cogs>

A hash reference with the calculated amounts for costs of goods

sold. The keys are chart IDs, the values the calculated amounts.

=item C<assembly_items>

An array reference with as many entries as there are items in the

record. Each entry is again an array reference of hash references with

the keys C<part> (an instance of L<SL::DB::Part>), C<qty> and

C<allocated>. Is only valid for invoices and can be used to populate

the C<invoice> table with entries for assemblies.

=item C<allocated>

A hash reference. The keys are IDs of entries in the C<invoice>

table. The values are the new values for the entry's C<allocated>

column. Only valid for invoices.

=item C<exchangerate>

The exchangerate used for the calculation.