use Data::Dumper;
use Carp;
+use Config;
use CGI;
use Cwd;
use Encode;
use File::Copy;
use IO::File;
+use Math::BigInt;
use SL::Auth;
use SL::Auth::DB;
use SL::Auth::LDAP;
use URI;
use List::Util qw(first max min sum);
use List::MoreUtils qw(all any apply);
+use SL::DB::Tax;
use strict;
# standard css for all
# this should gradually move to the layouts that need it
$layout->use_stylesheet("$_.css") for qw(
- main menu list_accounts jquery.autocomplete
+ main menu common list_accounts jquery.autocomplete
jquery.multiselect2side
ui-lightness/jquery-ui
jquery-ui.custom
$layout->use_javascript("$_.js") for (qw(
jquery jquery-ui jquery.cookie jquery.checkall jquery.download
jquery/jquery.form jquery/fixes client_js
- common part_selection switchmenuframe autocomplete_part
+ common part_selection switchmenuframe
), "jquery/ui/i18n/jquery.ui.datepicker-$::myconfig{countrycode}");
$self->{favicon} ||= "favicon.ico";
sub round_amount {
my ($self, $amount, $places) = @_;
- # Rounding like "Kaufmannsrunden" (see http://de.wikipedia.org/wiki/Rundung )
-
- # If you search for rounding in Perl, you'll likely get the first version of
- # this algorithm:
- #
- # ($amount <=> 0) * int(abs($amount) * 10**$places) + .5) / 10**$places
- #
- # That doesn't work. It falls apart for certain values that are exactly 0.5
- # over the cutoff, because the internal IEEE754 representation is slightly
- # below the cutoff. Perl makes matters worse in that it really, really tries to
- # recognize exact values for presentation to you, even if they are not.
- #
- # Example: take the value 64.475 and round to 2 places.
- #
- # printf("%.20f\n", 64.475) gives you 64.47499999999999431566
- #
- # Then 64.475 * 100 + 0.5 is 6447.99999999999909050530, and
- # int(64.475 * 100 + 0.5) / 100 = 64.47
- #
- # Trying to round with more precision first only shifts the problem to rarer
- # cases, which nevertheless exist.
- #
- # Now we exploit the presentation rounding of Perl. Since it really tries hard
- # to recognize integers, we double $amount, and let Perl give us a representation.
- # If Perl recognizes it as a slightly too small integer, and rounds up to the
- # next odd integer, we follow suit and treat the fraction as .5 or greater.
-
- my $sign = $amount <=> 0;
- $amount = abs $amount;
-
- my $shift = 10 ** ($places);
- my $shifted_and_double = $amount * $shift * 2;
- my $rounding_bias = sprintf('%f', $shifted_and_double) % 2;
- $amount = int($amount * $shift) + $rounding_bias;
- $amount = $amount / $shift * $sign;
+ # We use Perl's knowledge of string representation for
+ # rounding. First, convert the floating point number to a string
+ # with a high number of places. Then split the string on the decimal
+ # sign and use integer calculation for rounding the decimal places
+ # part. If an overflow occurs then apply that overflow to the part
+ # before the decimal sign as well using integer arithmetic again.
+
+ my $amount_str = sprintf '%.*f', $places + 10, abs($amount);
+
+ return $amount unless $amount_str =~ m{^(\d+)\.(\d+)$};
+
+ my ($pre, $post) = ($1, $2);
+ my $decimals = '1' . substr($post, 0, $places);
+
+ my $propagation_limit = $Config{i32size} == 4 ? 7 : 18;
+ my $add_for_rounding = substr($post, $places, 1) >= 5 ? 1 : 0;
+
+ if ($places > $propagation_limit) {
+ $decimals = Math::BigInt->new($decimals)->badd($add_for_rounding);
+ $pre = Math::BigInt->new($decimals)->badd(1) if substr($decimals, 0, 1) eq '2';
+
+ } else {
+ $decimals += $add_for_rounding;
+ $pre += 1 if substr($decimals, 0, 1) eq '2';
+ }
+
+ $amount = ("${pre}." . substr($decimals, 1)) * ($amount <=> 0);
return $amount;
}
$full_signature =~ s/\n/<br>\n/g;
$mail->{message} .= $full_signature;
- open(IN, "<", $self->{tmpfile})
+ open(IN, "<:encoding(UTF-8)", $self->{tmpfile})
or $self->error($self->cleanup . "$self->{tmpfile} : $!");
$mail->{message} .= $_ while <IN>;
close(IN);
push @err, $::locale->text('The application "#1" was not found on the system.', $application || 'pdflatex') . ' ' . $::locale->text('Please contact your administrator.');
} elsif (-f "$self->{tmpfile}.err") {
- open(FH, "$self->{tmpfile}.err");
+ open(FH, "<:encoding(UTF-8)", "$self->{tmpfile}.err");
@err = <FH>;
close(FH);
}
$key = "all_taxzones" unless ($key);
my $tzfilter = "";
- $tzfilter = "WHERE obsolete is FALSE" if $key eq 'ALL_ACTIVE_TAXZONES';
+ $tzfilter = "WHERE obsolete is FALSE" if $key eq 'ALL_ACTIVE_TAXZONES';
my $query = qq|SELECT * FROM tax_zones $tzfilter ORDER BY sortkey|;
return $self;
}
+sub calculate_arap {
+ my ($self,$buysell,$taxincluded,$exchangerate,$roundplaces) = @_;
+
+ # this function is used to calculate netamount, total_tax and amount for AP and
+ # AR transactions (Kreditoren-/Debitorenbuchungen) by going over all lines
+ # (1..$rowcount)
+ # Thus it needs a fully prepared $form to work on.
+ # calculate_arap assumes $form->{amount_$i} entries still need to be parsed
+
+ # The calculated total values are all rounded (default is to 2 places) and
+ # returned as parameters rather than directly modifying form. The aim is to
+ # make the calculation of AP and AR behave identically. There is a test-case
+ # for this function in t/form/arap.t
+
+ # While calculating the totals $form->{amount_$i} and $form->{tax_$i} are
+ # modified and formatted and receive the correct sign for writing straight to
+ # acc_trans, depending on whether they are ar or ap.
+
+ # check parameters
+ die "taxincluded needed in Form->calculate_arap" unless defined $taxincluded;
+ die "exchangerate needed in Form->calculate_arap" unless defined $exchangerate;
+ die 'illegal buysell parameter, has to be \"buy\" or \"sell\" in Form->calculate_arap\n' unless $buysell =~ /^(buy|sell)$/;
+ $roundplaces = 2 unless $roundplaces;
+
+ my $sign = 1; # adjust final results for writing amount to acc_trans
+ $sign = -1 if $buysell eq 'buy';
+
+ my ($netamount,$total_tax,$amount);
+
+ my $tax;
+
+ # parse and round amounts, setting correct sign for writing to acc_trans
+ for my $i (1 .. $self->{rowcount}) {
+ $self->{"amount_$i"} = $self->round_amount($self->parse_amount(\%::myconfig, $self->{"amount_$i"}) * $exchangerate * $sign, $roundplaces);
+
+ $amount += $self->{"amount_$i"} * $sign;
+ }
+
+ for my $i (1 .. $self->{rowcount}) {
+ next unless $self->{"amount_$i"};
+ ($self->{"tax_id_$i"}) = split /--/, $self->{"taxchart_$i"};
+ my $tax_id = $self->{"tax_id_$i"};
+
+ my $selected_tax = SL::DB::Manager::Tax->find_by(id => "$tax_id");
+
+ if ( $selected_tax ) {
+
+ if ( $buysell eq 'sell' ) {
+ $self->{AR_amounts}{"tax_$i"} = $selected_tax->chart->accno unless $selected_tax->taxkey == 0;
+ } else {
+ $self->{AP_amounts}{"tax_$i"} = $selected_tax->chart->accno unless $selected_tax->taxkey == 0;
+ };
+
+ $self->{"taxkey_$i"} = $selected_tax->taxkey;
+ $self->{"taxrate_$i"} = $selected_tax->rate;
+ };
+
+ ($self->{"amount_$i"}, $self->{"tax_$i"}) = $self->calculate_tax($self->{"amount_$i"},$self->{"taxrate_$i"},$taxincluded,$roundplaces);
+
+ $netamount += $self->{"amount_$i"};
+ $total_tax += $self->{"tax_$i"};
+
+ }
+ $amount = $netamount + $total_tax;
+
+ # due to $sign amount_$i und tax_$i already have the right sign for acc_trans
+ # but reverse sign of totals for writing amounts to ar
+ if ( $buysell eq 'buy' ) {
+ $netamount *= -1;
+ $amount *= -1;
+ $total_tax *= -1;
+ };
+
+ return($netamount,$total_tax,$amount);
+}
+
sub format_dates {
my ($self, $dateformat, $longformat, @indices) = @_;
return $layout;
}
+sub calculate_tax {
+ # this function calculates the net amount and tax for the lines in ar, ap and
+ # gl and is used for update as well as post. When used with update the return
+ # value of amount isn't needed
+
+ # calculate_tax should always work with positive values, or rather as the user inputs them
+ # calculate_tax uses db/perl numberformat, i.e. parsed numbers
+ # convert to negative numbers (when necessary) only when writing to acc_trans
+ # the amount from $form for ap/ar/gl is currently always rounded to 2 decimals before it reaches here
+ # for post_transaction amount already contains exchangerate and correct sign and is rounded
+ # calculate_tax doesn't (need to) know anything about exchangerate
+
+ my ($self,$amount,$taxrate,$taxincluded,$roundplaces) = @_;
+
+ $roundplaces = 2 unless defined $roundplaces;
+
+ my $tax;
+
+ if ($taxincluded *= 1) {
+ # calculate tax (unrounded), subtract from amount, round amount and round tax
+ $tax = $amount - ($amount / ($taxrate + 1)); # equivalent to: taxrate * amount / (taxrate + 1)
+ $amount = $self->round_amount($amount - $tax, $roundplaces);
+ $tax = $self->round_amount($tax, $roundplaces);
+ } else {
+ $tax = $amount * $taxrate;
+ $tax = $self->round_amount($tax, $roundplaces);
+ }
+
+ $tax = 0 unless $tax;
+
+ return ($amount,$tax);
+};
+
1;
__END__
projects / kivitendo-erp.git / blobdiff