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::DB::Chart;

use SL::DB::AccTransaction;

use SL::DB::BankAccount;

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;

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

my @where = ();

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

push @where, (transdate => { ge => $params{bank_account}->reconciliation_starting_date });

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

sort_by => $sort_by,

limit => 10000,

where => [

],

);

and => [ type => 'credit_note',

amount => { lt => \'paid' } # '} make emacs happy

],

],

],

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

my $all_open_ap_invoices = SL::DB::Manager::PurchaseInvoice->get_all(where => [amount => { ne => \'paid' }], # '}] make emacs happy

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

my $all_open_sepa_export_items = SL::DB::Manager::SepaExportItem->get_all(where => [chart_id => $params{bank_account}->chart_id ,

'sepa_export.executed' => 0,

'sepa_export.closed' => 0

],

with_objects => ['sepa_export']);

my @all_open_invoices;

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

my %sepa_exports;

foreach my $open_invoice (@all_open_invoices){

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

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

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

$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} += $_->amount * $factor;

push @{ $sepa_exports{$_->sepa_export_id}->{invoices} }, $open_invoice;

}

# 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);

$bt->{rule_matches} = [];

push(@proposals, $bt);

last;

}

# 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}

sepa_export_items => $all_open_sepa_export_items,

);

$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

my $proposal_threshold = 5;

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

my $dir = $params{sort_dir} ? 1 : -1;

}

sub action_list {

my ($self) = @_;

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

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

$self->action_search;

return;

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

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

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

my ($bank_transactions, $proposals) = $self->gather_bank_transactions_and_proposals(

bank_account => $bank_account,

fromdate => $fromdate,

todate => $todate,

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

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

);

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;

);

query => [ template_type => 'gl_transaction',

chart_id => SL::DB::Manager::BankAccount->find_by(id => $self->transaction->local_bank_account_id)->chart_id,

],

);

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

action => 'list',

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

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

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

));

if (1 == scalar @{ $templates_ap }) {

$self->redirect_to($self->load_ap_record_template_url($templates_ap->[0]));

} else {

my $dialog_html = $self->render(

'bank_transactions/create_invoice',

{ layout => 0, output => 0 },

title => t8('Create invoice'),

TEMPLATES_GL => $use_vendor_filter && @{ $templates_ap } ? undef : $templates_gl,

TEMPLATES_AP => $templates_ap,

vendor_name => $use_vendor_filter && @{ $templates_ap } ? $vendor_of_transaction->name : undef,

);

$self->js->run('kivi.BankTransaction.show_create_invoice_dialog', $dialog_html)->render;

}

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

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

invoice => $invoice,

);

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

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

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

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

push @filter_ap, @filter;

query => [ template_type => 'gl_transaction',

chart_id => SL::DB::Manager::BankAccount->find_by(id => $self->transaction->local_bank_account_id)->chart_id,

(and => \@filter) x !!@filter

],

with_objects => [ qw(employee record_template_items) ],

);

where => [ template_type => 'ap_transaction', (and => \@filter_ap) x !!@filter_ap ],

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(

TEMPLATES_GL => $templates_gl,

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' ]

# };

# might pay several open invoices with one transaction

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

foreach (@{ $::form->{proposal_ids} }) {

my $bank_transaction_id = $_;

my $invoice_ids = $invoice_hash{$_};

push @{ $self->problems }, $self->save_single_bank_transaction(

bank_transaction_id => $bank_transaction_id,

invoice_ids => $invoice_ids,