projekt kivitendo

package SL::Controller::BankTransaction;

# idee- möglichkeit bankdaten zu übernehmen in stammdaten

# erst Kontenabgleich, um alle gl-Einträge wegzuhaben

use strict;

use parent qw(SL::Controller::Base);

use SL::Controller::Helper::GetModels;

use SL::Controller::Helper::ReportGenerator;

use SL::ReportGenerator;

use SL::DB::BankTransaction;

use SL::Helper::Flash;

use SL::Locale::String;

use SL::SEPA;

use SL::DB::Invoice;

use SL::DB::PurchaseInvoice;

use SL::DB::RecordLink;

use SL::JSON;

use SL::DB::Chart;

use SL::DB::AccTransaction;

use SL::DB::Tax;

use SL::DB::BankAccount;

use List::MoreUtils qw(any);

use Rose::Object::MakeMethods::Generic

(

__PACKAGE__->run_before('check_auth');

#

# actions

#

sub action_search {

my ($self) = @_;

BANK_ACCOUNTS => $bank_accounts);

}

sub action_list_all {

my ($self) = @_;

$self->make_filter_summary;

$self->prepare_report;

sub action_list {

my ($self) = @_;

if (!$::form->{filter}{bank_account}) {

flash('error', t8('No bank account chosen!'));

$self->action_search;

return;

}

my $sort_by = $::form->{sort_by} || 'transdate';

$sort_by = 'transdate' if $sort_by eq 'proposal';

$sort_by .= $::form->{sort_dir} ? ' DESC' : ' ASC';

my $todate = $::locale->parse_date_to_object($::form->{filter}->{todate});

my @where = ();

push @where, (transdate => { ge => $fromdate }) if ($fromdate);

push @where, (transdate => { lt => $todate }) if ($todate);

# bank_transactions no younger than starting date,

if ( $bank_account->reconciliation_starting_date ) {

with_objects => [ 'local_bank_account', 'currency' ],

sort_by => $sort_by,

limit => 10000,

where => [

amount => {ne => \'invoice_amount'},

local_bank_account_id => $::form->{filter}{bank_account},

@where

],

);

my $all_open_ar_invoices = SL::DB::Manager::Invoice ->get_all(where => [ or => [ amount => { gt => \'paid' },

and => [ type => 'credit_note',

amount => { lt => \'paid' }

],

],

],

with_objects => ['customer','payment_terms']);

'sepa_export.executed' => 0, 'sepa_export.closed' => 0 ], with_objects => ['sepa_export']);

$main::lxdebug->message(LXDebug->DEBUG2(),"count sepaexport=".scalar(@{$all_open_sepa_export_items}));

my @all_open_invoices;

push @all_open_invoices, map { $_->{is_ar}=0 ; $_ } grep { abs($_->amount - $_->paid) >= 0.01 } @{ $all_open_ap_invoices };

my @all_sepa_invoices;

my @all_non_sepa_invoices;

my %sepa_exports;

# first collect sepa export items to open invoices

foreach my $open_invoice (@all_open_invoices){

# my @items = grep { $_->ap_id == $open_invoice->id || $_->ar_id == $open_invoice->id } @{$all_open_sepa_export_items};

$open_invoice->{realamount} = $::form->format_amount(\%::myconfig,$open_invoice->amount,2);

$open_invoice->{skonto_type} = 'without_skonto';

foreach ( @{$all_open_sepa_export_items}) {

if ( $_->ap_id == $open_invoice->id || $_->ar_id == $open_invoice->id ) {

$open_invoice->{realamount} = $::form->format_amount(\%::myconfig,$open_invoice->amount*$factor,2);

$open_invoice->{skonto_type} = $_->payment_type;

$sepa_exports{$_->sepa_export_id} ||= { count => 0, is_ar => 0, amount => 0, proposed => 0, invoices => [], item => $_ };

$sepa_exports{$_->sepa_export_id}->{count}++ ;

$sepa_exports{$_->sepa_export_id}->{is_ar}++ if $_->ar_id == $open_invoice->id;

# $sepa_exports{$_->sepa_export_id}->{amount}." count = ".

# $sepa_exports{$_->sepa_export_id}->{count}." is_ar = ".

# $sepa_exports{$_->sepa_export_id}->{is_ar} );

push @all_sepa_invoices , $open_invoice;

}

}

push @all_non_sepa_invoices , $open_invoice if ! $open_invoice->{sepa_export_item};

}

# try to match each bank_transaction with each of the possible open invoices

# by awarding points

foreach my $bt (@{ $bank_transactions }) {

$bt->amount($bt->amount*1);

$bt->invoice_amount($bt->invoice_amount*1);

$main::lxdebug->message(LXDebug->DEBUG2(),"BT ".$bt->id." amount=".$bt->amount." invoice_amount=".$bt->invoice_amount." remote=". $bt->{remote_name});

$bt->{rule_matches} = [];

foreach ( keys %sepa_exports) {

#$main::lxdebug->message(LXDebug->DEBUG2(),"has ".scalar($bt->{proposals})." invoices");

push(@proposals, $bt);

next;

}

}

}

next unless $bt->{remote_name}; # bank has no name, usually fees, use create invoice to assign

last if scalar (@all_sepa_invoices) == 0;

foreach my $open_invoice (@all_sepa_invoices){

$open_invoice->{rule_matches} ='';

#$main::lxdebug->message(LXDebug->DEBUG2(),"exitem2=".$_->id." for invoice ".$open_invoice->id);

my $factor = ( $_->ar_id == $open_invoice->id?1:-1);

$_->amount($_->amount*1);

$iban = $open_invoice->customer->iban if $open_invoice->is_sales;

$iban = $open_invoice->vendor->iban if ! $open_invoice->is_sales;

if($bt->{remote_account_number} eq $iban && abs(abs($open_invoice->amount) - abs($bt->amount)) < 0.01 ) {

($open_invoice->{agreement}, $open_invoice->{rule_matches}) = $bt->get_agreement_with_invoice($open_invoice);

$open_invoice->{agreement} += 5;

$open_invoice->{rule_matches} .= 'sepa_export_item(5) ';

$main::lxdebug->message(LXDebug->DEBUG2(),"sepa invoice_id=".$open_invoice->id." agreement=".$open_invoice->{agreement}." rules matches=".$open_invoice->{rule_matches});

$open_invoice->{realamount} = $::form->format_amount(\%::myconfig,$open_invoice->amount*$factor,2);

}

# results of get_agreement_with_invoice in $open_invoice->{agreement} and

# $open_invoice->{rule_matches}.

# The values are overwritten each time a new bt is checked, so at the end

# of each bt the likely results are filtered and those values are stored in

# the arrays $bt->{proposals} and $bt->{rule_matches}, and the agreement

# score is stored in $bt->{agreement}

$open_invoice->amount * ($open_invoice->{is_ar} ? 1 : -1), 2);

}

my $min_agreement = 3; # suggestions must have at least this score

if ( $max_agreement >= $min_agreement ) {

$bt->{proposals} = [ grep { $_->{agreement} == $max_agreement } @all_open_invoices ];

$bt->{agreement} = $max_agreement; #scalar @{ $bt->{proposals} } ? $agreement + 1 : '';

foreach ( @{ $bt->{proposals} } ) {

push(@{$bt->{rule_matches}}, $_->{rule_matches});

};

};

# finished all bt

# separate filter for proposals (second tab, agreement >= 5 and exactly one match)

# to qualify as a proposal there has to be

# * there must be only one exact match

&& (1 == scalar @{ $_->{proposals} })

&& (@{ $_->{proposals} }[0]->is_sales ? abs(@{ $_->{proposals} }[0]->amount - $_->amount) < 0.01

: abs(@{ $_->{proposals} }[0]->amount + $_->amount) < 0.01)

} @{ $bank_transactions };

$bank_transactions = [ sort { $b->{agreement} <=> $a->{agreement} } @{ $bank_transactions } ] if $::form->{sort_by} eq 'proposal' and $::form->{sort_dir} == 0;

PROPOSALS => \@proposals,

ui_tab => scalar(@proposals) > 0?1:0,

);

sub action_assign_invoice {

my ($self) = @_;

$self->{transaction} = SL::DB::Manager::BankTransaction->find_by(id => $::form->{bt_id});

{ layout => 0 },

title => t8('Assign invoice'),);

sub action_create_invoice {

my ($self) = @_;

my %myconfig = %main::myconfig;

my $use_vendor_filter = $self->transaction->{remote_account_number} && $vendor_of_transaction;

where => [ template_type => 'ap_transaction' ],

with_objects => [ qw(employee vendor) ],

);

$templates = [ grep { $_->vendor_id == $vendor_of_transaction->id } @{ $templates } ] if $use_vendor_filter;

action => 'list',

'filter.bank_account' => $::form->{filter}->{bank_account},

'filter.todate' => $::form->{filter}->{todate},

'filter.fromdate' => $::form->{filter}->{fromdate},

));

$self->render(

'bank_transactions/create_invoice',

{ layout => 0 },

title => t8('Create invoice'),

vendor_name => $use_vendor_filter ? $vendor_of_transaction->name : undef,

);

my ($self) = @_;

# based on a BankTransaction ID and a Invoice or PurchaseInvoice ID passed via $::form,

# create an HTML blob to be used by the js function add_invoices in templates/webpages/bank_transactions/list.html

# and return encoded as JSON

my $invoice = SL::DB::Manager::Invoice->find_by( id => $::form->{prop_id} ) || SL::DB::Manager::PurchaseInvoice->find_by( id => $::form->{prop_id} );

die unless $bt and $invoice;

my @select_options = $invoice->get_payment_select_options_for_bank_transaction($::form->{bt_id});

my $html;

'bank_transactions/_payment_suggestion', { output => 0 },

bt_id => $::form->{bt_id},

prop_id => $::form->{prop_id},

invoice => $invoice,

SELECT_OPTIONS => \@select_options,

);

$self->render(\ SL::JSON::to_json( { 'html' => "$html" } ), { layout => 0, type => 'json', process => 0 });

push @filter, ('vendor.id' => $::form->{vendor_id}) if $::form->{vendor_id};

push @filter, ('vendor.name' => { ilike => '%' . $::form->{vendor} . '%' }) if $::form->{vendor};

where => [ template_type => 'ap_transaction', (or => \@filter) x !!@filter ],

with_objects => [ qw(employee vendor) ],

);

action => 'list',

'filter.bank_account' => $::form->{filter}->{bank_account},

'filter.todate' => $::form->{filter}->{todate},

'filter.fromdate' => $::form->{filter}->{fromdate},

));

my $output = $self->render(

sub action_ajax_add_list {

my ($self) = @_;

my @where_sale = (amount => { ne => \'paid' });

my @where_purchase = (amount => { ne => \'paid' });

if ($::form->{invnumber}) {

push @where_purchase, (invnumber => { ilike => like($::form->{invnumber})});

if ($::form->{amount}) {

push @where_sale, (amount => $::form->parse_amount(\%::myconfig, $::form->{amount}));

push @where_purchase, (amount => $::form->parse_amount(\%::myconfig, $::form->{amount}));

}

if ($::form->{vcnumber}) {

push @where_purchase, ('vendor.vendornumber' => { ilike => like($::form->{vcnumber})});

if ($::form->{vcname}) {

push @where_purchase, ('vendor.name' => { ilike => like($::form->{vcname})});

if ($::form->{transdatefrom}) {

if ( ref($fromdate) eq 'DateTime' ) {

push @where_sale, ('transdate' => { ge => $fromdate});

push @where_purchase, ('transdate' => { ge => $fromdate});

};

if ($::form->{transdateto}) {

if ( ref($todate) eq 'DateTime' ) {

$todate->add(days => 1);

push @where_sale, ('transdate' => { lt => $todate});

push @where_purchase, ('transdate' => { lt => $todate});

};

# add ap invoices, filtering out subcent open amounts

@all_open_invoices = sort { $a->id <=> $b->id } @all_open_invoices;

my $output = $self->render(

{ output => 0 },

INVOICES => \@all_open_invoices,

);

my %result = ( count => 0, html => $output );

$self->render(\to_json(\%result), { type => 'json', process => 0 });

}

sub action_ajax_accept_invoices {

my ($self) = @_;

my @selected_invoices;

foreach my $invoice_id (@{ $::form->{invoice_id} || [] }) {

}

'bank_transactions/invoices',

{ layout => 0 },

INVOICES => \@selected_invoices,

bt_id => $::form->{bt_id},

);

my %invoice_hash = %{ delete $::form->{invoice_ids} }; # each key (the bt line with a bt_id) contains an array of invoice_ids

# e.g. three partial payments with bt_ids 54, 55 and 56 for invoice with id 74:

# $invoice_hash = {

# '55' => [

# '74'

# ],

# '54' => [

# '74'

# ],

# '56' => [

# '74'

# ]

# };

#

# or if the payment with bt_id 44 is used to pay invoices with ids 50, 51 and 52

# $invoice_hash = {

# '44' => [ '50', '51', 52' ]

# };