projekt kivitendo

package SL::DB::Helper::Payment;

use strict;

use parent qw(Exporter);

our @EXPORT = qw(pay_invoice);

"ALL" => [@EXPORT, @EXPORT_OK],

);

require SL::DB::Chart;

use Carp;

use DateTime;

use List::Util qw(sum);

use SL::DATEV qw(:CONSTANTS);

use SL::DB::Currency;

#

# Public functions not exported by default

#

sub pay_invoice {

my ($self, %params) = @_;

my $is_sales = ref($self) eq 'SL::DB::Invoice';

my $mult = $is_sales ? 1 : -1; # multiplier for getting the right sign depending on ar/ap

# default values if not set

$params{payment_type} = 'without_skonto' unless $params{payment_type};

validate_payment_type($params{payment_type});

# three valid cases, test logical params in depth, before proceeding ...

croak "invalid amount for payment_type 'without_skonto': $params{'amount'}\n";

# we force caller input for amount and skonto amount

$params{skonto_amount} = _round($params{skonto_amount});

$params{amount} = _round($params{amount});

if ($params{skonto_amount} > _round($self->open_amount)) {

croak("Skonto amount:" . $params{skonto_amount} . " higher than the payment or open invoice amount:" . $self->open_amount);

# options with_skonto_pt doesn't require the parameter

# amount, but if amount is passed, make sure it matches the expected value

# note: the parameter isn't used at all - amount_less_skonto will always be used

# partial skonto payments are therefore impossible to book

croak "amount $params{amount} doesn't match amount less skonto: " . $self->amount_less_skonto . "\n" if $params{amount} && abs($self->amount_less_skonto - $params{amount} ) > 0.0000001;

croak "payment type with_skonto_pt can't be used if payments have already been made" if $self->paid != 0;

} else {

# check for closed period

my $closedto = $::locale->parse_date_to_object($::instance_conf->get_closedto);

if ( ref $closedto && $transdate_obj < $closedto ) {

croak t8('Cannot post payment for a closed period!');

};

# check for maximum number of future days

if ( $::instance_conf->get_max_future_booking_interval > 0 ) {

croak t8('Cannot post transaction above the maximum future booking date!') if $transdate_obj > DateTime->now->add( days => $::instance_conf->get_max_future_booking_interval );

};

# dies if called for a invoice with the default currency (TODO: Params::Validate before)

$currency = SL::DB::Manager::Currency->find_by(name => $params{currency}) || SL::DB::Manager::Currency->find_by(id => $params{currency_id});

die "No currency found" unless ref $currency eq 'SL::DB::Currency';

die "No exchange rate" unless $params{exchangerate} > 0;

# VORHER

# my $gain_loss_amount = _round($amount * ($exchangerate - $self->get_exchangerate ) * -1,2);

# $fx_gain_loss_amount = _round($self->open_amount / $self->get_exchangerate - $new_open_amount / $exchangerate);

$main::lxdebug->message(0, 'h 1 ' . $new_open_amount . ' h 3 ' . $params{amount});

# if new open amount for payment booking is smaller than original amount use this

# assume that the rest are fees, if the user selected this

if ($params{fx_book} && $params{fx_fee_amount} > 0) {

die "Bank Fees can only be added for AP transactions or Sales Credit Notes"

unless $self->invoice_type =~ m/purchase_invoice|ap_transaction|credit_note/;

$self->_add_bank_fx_fees(fee => _round($params{fx_fee_amount}),

bt_id => $params{bt_id},

bank_chart_id => $params{chart_id},

memo => $params{memo},

source => $params{source},

transdate_obj => $transdate_obj );

# invoice_amount add gl booking

$main::lxdebug->message(0, 'fee ' . $params{fx_fee_amount});

$return_bank_amount += _round($params{fx_fee_amount}); # invoice_type needs negative bank_amount

$main::lxdebug->message(0, 'bank_amount' . $return_bank_amount);

#$fx_gain_loss_amount = _round($params{amount} - ($params{amount} / $self->get_exchangerate * $exchangerate) );

die "Cannot calculate exchange rate, if invoices uses the default currency";

}

# calculated skontos add up

# only needed for payment_term "with_skonto_pt"

my $skonto_amount_check = $self->skonto_amount; # variable should be zero after calculating all skonto

my $total_open_amount = $self->open_amount;

# account where money is paid to/from: bank account or cash

my $account_bank = SL::DB::Manager::Chart->find_by(id => $params{chart_id});

my $reference_account = $self->reference_account;

croak "can't find reference account (link = AR/AP) for invoice" unless ref $reference_account;

my $source = $params{source} // '';

# all three payment type create 1 AR/AP booking (the paid part)

# and one tax correction as a gl booking

# for case with_skonto_pt we need to know the corrected amount at this

my $pay_amount = $rounded_params_amount;

$pay_amount = $self->amount_less_skonto if $params{payment_type} eq 'with_skonto_pt';

# bank account and AR/AP

my $amount = (-1 * $pay_amount) * $mult;

$main::lxdebug->message(0, 'paidamount:' . $paid_amount);

# total amount against bank, do we already know this by now?

chart_id => $account_bank->id,

chart_link => $account_bank->link,

source => $source,

memo => $memo,

tax_id => SL::DB::Manager::Tax->find_by(taxkey => 0)->id);

$new_acc_trans->save;

$main::lxdebug->message(0, 'return 5 :' . $return_bank_amount);

$main::lxdebug->message(0, 'paid amount hier 1 :' . $paid_amount);

# if invoice exchangerate differs from exchangerate of payment

# add fxloss or fxgain

my $fxloss_chart = SL::DB::Manager::Chart->find_by(id => $::instance_conf->get_fxloss_accno_id) || die "Can't determine fxloss chart";

# rate invoice = 2, fx rate paid = 1.75

# partial payment of 15000 EUR invtotal 20000

# 15000/1.75 * (2 - 1.75) = 2142. EUR gain if invoice is purchase # sql ledger (with fx amount):

# AR.pm

# $amount = $form->round_amount($form->{"paid_$i"} * ($form->{exchangerate} - $form->{"exchangerate_$i"}) * -1, 2);

# AP.pm

# exchangerate gain/loss

# $amount = $form->round_amount($form->{"paid_$i"} * ($form->{exchangerate} - $form->{"exchangerate_$i"}), 2);

# ==>

# my $fx_gain_loss_sign = $is_sales ? -1 : 1; # multiplier for getting the right sign depending on ar/ap

#my $fx_gain_loss_sign = $self->invoice_type =~ m/purchase_invoice|ap_transaction|credit_note/ ? 1

# : $self->invoice_type =~ m/invoice|ar_transaction|purchase_credit_note|invoice_for_advance_payment/ ? -1

# : die "invalid state";

$fx_gain_loss_amount = _round($amount / $exchangerate * ( $self->get_exchangerate - $exchangerate)); # * $fx_gain_loss_sign;

$main::lxdebug->message(0, 'was sagt gain loss 2 ' . $fx_gain_loss_amount);

# die "huchz" . $fx_gain_loss_amount;

# for sales add loss to ar.paid and subtract gain from ar.paid

# for purchase add gain to ap.paid and subtract loss from ap.paid

$paid_amount += abs($fx_gain_loss_amount) if $fx_gain_loss_amount < 0 && $self->is_sales; # extract if we have fx_loss

$paid_amount -= abs($fx_gain_loss_amount) if $fx_gain_loss_amount > 0 && $self->is_sales; # but add if to match original invoice amount (arap)

$paid_amount += abs($fx_gain_loss_amount) if $fx_gain_loss_amount > 0 && !$self->is_sales; # but add if to match original invoice amount (arap)

$paid_amount -= abs($fx_gain_loss_amount) if $fx_gain_loss_amount < 0 && !$self->is_sales; # extract if we have fx_loss

# (self->amount - self->paid) / $self->exchangerate

$main::lxdebug->message(0, 'paid dort 2 ' . $paid_amount);

$main::lxdebug->message(0, 'paid amount hier 2 ' . $paid_amount);

# $return_bank_amount += $fx_gain_loss_amount if $fx_gain_loss_amount < 0; # only add if we have fx_loss

chart_link => $gain_loss_chart->link,

amount => $fx_gain_loss_amount,

source => $source,

memo => $memo,

taxkey => 0,

$new_acc_trans->save;

}

if ($params{payment_type} eq 'with_skonto_pt' or $params{payment_type} eq 'free_skonto' ) {

my $total_skonto_amount;

if ( $params{payment_type} eq 'with_skonto_pt' ) {

$total_skonto_amount = $self->skonto_amount;

$total_skonto_amount = $params{skonto_amount};

}

transdate_obj => $transdate_obj, memo => $params{memo},

source => $params{source});

# create an acc_trans entry for each result of $self->skonto_charts

foreach my $skonto_booking ( @skonto_bookings ) {

next unless $skonto_booking->{'chart_id'};

next unless $skonto_booking->{'skonto_amount'} != 0;

my $amount = -1 * $skonto_booking->{skonto_amount};

$new_acc_trans = SL::DB::AccTransaction->new(trans_id => $self->id,

chart_id => $skonto_booking->{'chart_id'},

transdate => $transdate_obj,

source => $params{source},

taxkey => 0,

tax_id => SL::DB::Manager::Tax->find_by(taxkey => 0)->id);

# the acc_trans entries are saved individually, not added to $self and then saved all at once

$reference_amount -= abs($amount);

} elsif ( $params{payment_type} eq 'with_skonto_pt' ) {

# this should be amount + sum(amount+skonto), but while we only allow

# with_skonto_pt for completely unpaid invoices we just use the value

# from the invoice

$arap_amount = $total_open_amount;

# we forced positive values and forced rounding at the beginning

# therefore the above comment can be safely applied for this payment type

$arap_amount = $params{amount} + $params{skonto_amount};

# regardless of payment_type there is always only exactly one arap booking

chart_id => $reference_account->id,

chart_link => $reference_account->link,

source => '', #$params{source},

taxkey => 0,

tax_id => SL::DB::Manager::Tax->find_by(taxkey => 0)->id);

$arap_booking->save;

die "No Clearing Chart for Advance Payment" unless ref $clearing_chart eq 'SL::DB::Chart';

# what does ptc say

my %inv_calc = $self->calculate_prices_and_taxes();

my @trans_ids = keys %{ $inv_calc{amounts} };

die "Invalid state for advance payment more than one trans_id" if (scalar @trans_ids > 1);

my $entry = delete $inv_calc{amounts}{$trans_ids[0]};

my $tax;

if ($entry->{tax_id}) {

$tax = SL::DB::Manager::Tax->find_by(id => $entry->{tax_id}); # || die "Can't find tax with id " . $entry->{tax_id};

}

if ($tax and $tax->rate != 0) {

my ($netamount, $taxamount);

my $roundplaces = 2;

# we dont have a clue about skonto, that's why we use $arap_amount as taxincluded

($netamount, $taxamount) = Form->calculate_tax($arap_amount, $tax->rate, 1, $roundplaces);

# for debugging database set

my $fullmatch = $netamount == $entry->{amount} ? '::netamount total true' : '';

: $tax->taxkey == 3 ? SL::DB::Chart->new(id => $::instance_conf->get_advance_payment_taxable_19_id)->load

: undef;

die "No Transfer Chart for Advance Payment" unless ref $transfer_chart eq 'SL::DB::Chart';

my $arap_full_booking= SL::DB::AccTransaction->new(trans_id => $self->id,

chart_id => $clearing_chart->id,

chart_link => $clearing_chart->link,

amount => $arap_amount * -1, # full amount

transdate => $transdate_obj,

source => 'Automatic Tax Booking for Payment in Advance' . $fullmatch,

taxkey => 0,

tax_id => SL::DB::Manager::Tax->find_by(taxkey => 0)->id);

$arap_full_booking->save;

push @new_acc_ids, $arap_full_booking->acc_trans_id;

my $arap_tax_booking= SL::DB::AccTransaction->new(trans_id => $self->id,

chart_id => $transfer_chart->id,

chart_link => $transfer_chart->link,

amount => _round($netamount), # full amount

transdate => $transdate_obj,

source => 'Automatic Tax Booking for Payment in Advance' . $fullmatch,

taxkey => $tax->taxkey,

tax_id => $tax->id);

$arap_tax_booking->save;

push @new_acc_ids, $arap_tax_booking->acc_trans_id;

chart_id => $tax->chart_id,

chart_link => $tax->chart->link,

amount => _round($taxamount),

transdate => $transdate_obj,

source => 'Automatic Tax Booking for Payment in Advance' . $fullmatch,

taxkey => 0,

tax_id => SL::DB::Manager::Tax->find_by(taxkey => 0)->id);

$tax_booking->save;

push @new_acc_ids, $tax_booking->acc_trans_id;

}

$self->paid($self->paid + _round($paid_amount)) if $paid_amount;

$self->save;

# is called, as pay_invoice saves the acc_trans objects individually rather

# than adding them to the transaction relation array.

$self->forget_related('transactions');

if ( $is_sales ) {

if ( ( $self->invoice && $::instance_conf->get_datev_check_on_sales_invoice ) ||

( !$self->invoice && $::instance_conf->get_datev_check_on_ar_transaction )) {

$datev_check = 1;

}

} else {

if ( ( $self->invoice && $::instance_conf->get_datev_check_on_purchase_invoice ) ||

( !$self->invoice && $::instance_conf->get_datev_check_on_ap_transaction )) {

$datev_check = 1;

}

}

dbh => $db->dbh,

trans_id => $self->{id},

);

}

$return_bank_amount *= -1; # negative booking is positive bank transaction

# positive booking is negative bank transaction

return wantarray ? ( { return_bank_amount => $return_bank_amount }, @new_acc_ids) : 1;

sub skonto_date {

my $self = shift;

sub reference_account {

my $self = shift;

my $is_sales = ref($self) eq 'SL::DB::Invoice';

require SL::DB::Manager::AccTransaction;

my $link_filter = $is_sales ? 'AR' : 'AP';

my $acc_trans = SL::DB::Manager::AccTransaction->find_by(

'!chart_id' => $::instance_conf->get_advance_payment_clearing_chart_id,

);

return undef unless ref $acc_trans;

my $reference_account = SL::DB::Manager::Chart->find_by(id => $acc_trans->chart_id);

return $reference_account;

sub open_amount {

my $self = shift;

# in the future maybe calculate this from acc_trans

# if the difference is 0.01 Cent this may end up as 0.009999999999998

# numerically, so round this value when checking for cent threshold >= 0.01

# validate shift == $self

validate_pos(

@_,

{ can => [ qw(forex get_exchangerate) ],

callbacks => { 'has forex' => sub { return $_[0]->forex } } },

{ callbacks => {

'is a positive real' => sub { return $_[0] =~ m/^[+]?\d+(\.\d+)?$/ }, },

}

);

my ($self, $fx_rate) = @_;

return ( $self->open_amount / $self->get_exchangerate ) * $fx_rate;

}

sub amount_less_skonto_fx {

# validate shift == $self

validate_pos(

@_,

{ can => [ qw(forex get_exchangerate percent_skonto) ],

callbacks => { 'has forex' => sub { return $_[0]->forex } } },

{ callbacks => {

'is a positive real' => sub { return $_[0] =~ m/^[+]?\d+(\.\d+)?$/ }, },

}

);

my ($self, $fx_rate) = @_;

return ( $self->amount_less_skonto / $self->get_exchangerate ) * $fx_rate;

}

my $self = shift;

return $self->amount - $self->amount_less_skonto;

sub percent_skonto {

my $self = shift;

my $percent_skonto = 0;

return undef unless $self->payment_terms->percent_skonto > 0;

$percent_skonto = $self->payment_terms->percent_skonto;

return $percent_skonto;

sub amount_less_skonto {

# amount that has to be paid if skonto applies, always return positive rounded values

# and therefore this comment may be misguiding

my $self = shift;