projekt kivitendo

use Carp;

use Support::TestSetup;

use_ok 'SL::BackgroundJob::CreatePeriodicInvoices';

use_ok 'SL::DB::Chart';

# Clean up: remove invoices, orders, parts and customers

clear_up();

name => 'Test Customer',

%{ $params{customer} }

)->save;

partnumber => 'T4254',

description => 'Fourty-two fifty-four',

lastcost => 222.22,

%{ $params{part} }

)->save;

save => 1,

customer => $customer,

transaction_description => '<%period_start_date%>',

use SL::DB::PurchaseInvoice;

use SL::DB::BankTransaction;

use SL::Controller::BankTransaction;

use Data::Dumper;

my ($customer, $vendor, $currency_id, $unit, $tax, $tax7, $tax_9, $payment_terms, $bank_account);

name => SL::DB::Manager::Chart->find_by(description => 'Bank')->description,

)->save;

name => 'Test Customer',

iban => 'DE12500105170648489890',

bic => 'TESTBIC',

customernumber => 'CUST1704',

)->save;

name => 'Test Vendor',

payment_id => $payment_terms->id,

iban => 'DE12500105170648489890',

$ar_transaction = test_ar_transaction(invnumber => 'salesinv1');

$::form->{invoice_ids} = {

$bt->id => [ $ar_transaction->id ]

payment_id => $payment_terms->id,

);

$::form->{invoice_ids} = {

$bt->id => [ $ar_transaction->id ]

my $ar_transaction_1 = test_ar_transaction(invnumber => 'salesinv_1');

my $ar_transaction_2 = test_ar_transaction(invnumber => 'salesinv_2');

my ($agreement, $rule_matches) = $bt->get_agreement_with_invoice($ar_transaction_1);

is($agreement, 16, "points for ar_transaction_1 in test_two_invoices ok");

$ar_transaction = test_ar_transaction(invnumber => 'salesinv overpaid');

# amount 135 > 119

$::form->{invoice_ids} = {

$bt->id => [ $ar_transaction->id ]

$ar_transaction = test_ar_transaction(invnumber => 'salesinv overpaid partial');

$::form->{invoice_ids} = {

$bt_1->id => [ $ar_transaction->id ]

$ar_transaction = test_ar_transaction(invnumber => 'salesinv partial payment');

# amount 100 < 119

$::form->{invoice_ids} = {

$bt->id => [ $ar_transaction->id ]

my $testname = 'test_credit_note';

invnumber => 'cn 1',

customer => $customer,

taxincluded => 0,

]

);

amount => $credit_note->amount,

bank_chart_id => $bank->id,

transdate => DateTime->today->add(days => 10),

is($invoice->netamount, -20 , "$testname: netamount ok");

is($invoice->amount , -23.8, "$testname: amount ok");

);

my ($agreement, $rule_matches) = $bt->get_agreement_with_invoice($invoice);

is($agreement, 15, "points for negative ap transaction ok");

is($invoice->netamount, 115 , "$testname: netamount ok");

is($invoice->amount , 136.85, "$testname: amount ok");

$::form->{invoice_ids} = {

$bt->id => [ $invoice->id ]

};

is($invoice->netamount, 115 , "$testname: netamount ok");

is($invoice->amount , 136.85, "$testname: amount ok");

$::form->{invoice_ids} = {

$bt->id => [ $invoice->id ]

};

is($invoice->paid , '36.85000', "$testname: paid ok");

is($bt->invoice_amount, '-36.85000', "$testname: bt invoice amount for ap was assigned");

$::form->{invoice_ids} = {

$bt2->id => [ $invoice->id ]

};

my $testname = 'test_neg_sales_invoice';

invnumber => '20172201',

customer => $customer,

taxincluded => 0,

]

);

amount => $neg_sales_inv->amount,

bank_chart_id => $bank->id,

transdate => DateTime->today,

$ar_transaction = test_ar_transaction(invnumber => 'bt_rule1');

$ar_transaction->load;

$bt->load;

$ar_transaction = test_ar_transaction(invnumber => 'sepa1');

chart_id => $bank->id,

ar_id => $ar_transaction->id,

sepa_export_id => $se->id,

use Carp;

use Support::TestSetup;

use_ok 'SL::BackgroundJob::CreatePeriodicInvoices';

use_ok 'SL::Controller::FinancialControllingReport';

$unit = SL::DB::Manager::Unit->find_by(name => 'psch') || croak "No unit";

}

my %params = @_;

cleanup();

$params{$_} ||= {} for qw(customer part order orderitem);

name => 'Test Customer',

%{ $params{customer} }

)->save;

partnumber => 'T4254',

description => 'Fourty-two fifty-four',

lastcost => 222.22,

)->save;

$part->load;

save => 1,

customer => $customer,

transaction_description => '<%period_start_date%>',

transdate => DateTime->from_kivitendo('01.03.2014'),

orderitems => [

part => $part,

qty => 1,

%{ $params{orderitem} },

sub run_tests {

my ($msg, $num_orders, $values, %order_params) = @_;

is($num_orders, scalar @{ $ctrl->orders }, "${msg}, #orders");

is_deeply([ map { ($ctrl->orders->[0]->{$_} // 0) * 1 } @columns ],

use Carp;

use Support::TestSetup;

use_ok 'SL::BackgroundJob::CreatePeriodicInvoices';

use_ok 'SL::Controller::FinancialOverview';

$unit = SL::DB::Manager::Unit->find_by(name => 'psch') || croak "No unit";

}

my %params = @_;

$params{$_} ||= {} for qw(customer part order orderitem);

# Clean up: remove invoices, orders, parts and customers

clear_up();

name => 'Test Customer',

%{ $params{customer} }

)->save;

partnumber => 'T4254',

description => 'Fourty-two fifty-four',

lastcost => 222.22,

)->save;

$part->load;

save => 1,

customer => $customer,

transaction_description => '<%period_start_date%>',

transdate => DateTime->from_kivitendo('01.03.2014'),

periodic_invoices_config => $params{periodic_invoices_config} ? {

active => 1,

ar_chart_id => $ar_chart->id,

# ----------------------------------------------------------------------

# An order without periodic invoices:

is_deeply($ctrl->data->{$_}, { months => [ (0) x 12 ], quarters => [ 0, 0, 0, 0 ], year => 0 }, "no periodic invoices, data for $_")

for qw(purchase_invoices purchase_orders requests_for_quotation sales_invoices sales_quotations);

# ----------------------------------------------------------------------

# order_value_periodicity=y, periodicity=q

periodic_invoices_config => {

periodicity => 'm',

order_value_periodicity => 'y',

# ----------------------------------------------------------------------

# order_value_periodicity=y, periodicity=q, starting in previous year

order => {

transdate => DateTime->from_kivitendo('01.03.2013'),

},

# ----------------------------------------------------------------------

# order_value_periodicity=y, periodicity=q, starting in previous year, ending middle of year

order => {

transdate => DateTime->from_kivitendo('01.03.2013'),

},

# ----------------------------------------------------------------------

# order_value_periodicity=y, periodicity=q, starting and ending before current

order => {

transdate => DateTime->from_kivitendo('01.03.2012'),

},

use Support::TestSetup;

use Carp;

use Test::Exception;

use SL::DB::Part;

use SL::DB::Order;

use SL::DB::Customer;

clear_up();

# sales order with globalproject_id and item project_ids

save => 1,

customer => $customer,

globalproject_id => $project->id,

taxincluded => 0,

]

);

# sales order with no globalproject_id but item project_ids

save => 1,

customer => $customer,

taxincluded => 0,

]

);

# purchase order with globalproject_id and item project_ids

save => 1,

vendor => $vendor,

globalproject_id => $project->id,

taxincluded => 0,

]

);

# sales_invoice with globalproject_id, and all items with project_id

customer => $customer,

globalproject_id => $project->id,

taxincluded => 0,

]

);

# sales_invoice with globalproject_id, but none of the items has a project_id

customer => $customer,

globalproject_id => $project->id,

taxincluded => 0,

]

);

# one of the invoice items has the project id, but there is no globalproject_id

customer => $customer,

taxincluded => 0,

]

);

use_ok 'Support::TestSetup';

use SL::DATEV qw(:CONSTANTS);

use List::Util qw(sum);

use SL::DB::Buchungsgruppe;

use SL::DB::Chart;

my $payment_date = DateTime->new(year => 2017, month => 1, day => 5);

my $gldate = DateTime->new(year => 2017, month => 2, day => 9); # simulate bookings for Jan being made in Feb

partnumber => '7',

description => 'Part 7%',

buchungsgruppen_id => $buchungsgruppe7->id,

)->save;

invnumber => "1 sales invoice",

itime => $gldate,

gldate => $gldate,

intnotes => 'booked in February',

taxincluded => 0,

transdate => $date,

]

);

$invoice->pay_invoice(chart_id => $bank->id,

], "trans_id datev check ok";

my $march_9 = DateTime->new(year => 2017, month => 3, day => 9);

invnumber => "2 sales invoice",

itime => $march_9,

gldate => $march_9,

intnotes => 'booked in March',

taxincluded => 0,

transdate => $date,

]

);

invnumber => 'Gutschrift 34',

itime => $gldate,

gldate => $gldate,

intnotes => 'booked in February',

taxincluded => 0,

transdate => $date,

]

);

use SL::DB::Part;

use SL::DB::Unit;

my ($customer, $employee, $payment_do, $unit, @parts, $department);

clear_up();

$unit = SL::DB::Manager::Unit->find_by(name => 'kg') || die "Can't find unit 'kg'";

$employee = SL::DB::Employee->new(

'login' => 'testuser',

'description' => 'Test Department',

)->save;

'description' => '14Tage 2%Skonto, 30Tage netto',

'description_long' => "Innerhalb von 14 Tagen abzüglich 2 % Skonto, innerhalb von 30 Tagen rein netto.|Bei einer Zahlung bis zum <%skonto_date%> gewähren wir 2 % Skonto (EUR <%skonto_amount%>) entspricht EUR <%total_wo_skonto%>.Bei einer Zahlung bis zum <%netto_date%> ist der fällige Betrag in Höhe von <%total%> <%currency%> zu überweisen.",

'percent_skonto' => '0.02',

# two real parts

@parts = ();

description => "description 1",

lastcost => '49.95000',

listprice => '0.00000',

weight => '0.79',

)->save;

description => "description 2",

lastcost => '153.00000',

listprice => '0.00000',

reset_state();

# we create L20199 with two items

'department_id' => $department->id,

'donumber' => 'L20199',

'employee_id' => $employee->id,

'customer_id' => $customer->id,

'notes' => '<ul><li><strong>fett</strong></li><li><strong>und</strong></li><li><strong>mit</strong></li><li><strong>bullets</strong></li><li>&nbsp;</li></ul>',

orderitems => [

part => $parts[0],

discount => '0.25',

lastcost => '49.95000',

sellprice => '242.20000',

unit => $unit->name,

),

part => $parts[1],

discount => '0.25',

lastcost => '153.00000',

use Test::Exception;

use List::Util qw(sum);

use SL::DB::Buchungsgruppe;

use SL::DB::Currency;

use SL::DB::Exchangerate;

currency_id => $currency->id,

)->save;

name => 'Test Customer',

currency_id => $currency_id,

taxzone_id => $taxzone->id,

auto_calculation => 1,

)->save;

name => 'Test Vendor',

currency_id => $currency_id,

taxzone_id => $taxzone->id,

@parts = ();

partnumber => 'T4254',

description => 'Fourty-two fifty-four',

lastcost => 1.93,

%{ $params{part1} }

)->save;

partnumber => 'T0815',

description => 'Zero EIGHT fifteeN @ 7%',

lastcost => 5.473,

unit => $unit->name,

%{ $params{part2} }

)->save;

partnumber => '19%',

description => 'Testware 19%',

lastcost => 0,

unit => $unit->name,

%{ $params{part3} }

)->save;

partnumber => '7%',

description => 'Testware 7%',

lastcost => 0,

sub test_default_invoice_one_item_19_without_skonto() {

reset_state() if $ALWAYS_RESET;

taxincluded => 0,

invoiceitems => [ $item ],

payment_id => $payment_terms->id,

sub test_default_invoice_one_item_19_without_skonto_overpaid() {

reset_state() if $ALWAYS_RESET;

taxincluded => 0,

invoiceitems => [ $item ],

payment_id => $payment_terms->id,

sub test_default_invoice_two_items_19_7_tax_with_skonto() {

reset_state() if $ALWAYS_RESET;

taxincluded => 0,

invoiceitems => [ $item1, $item2 ],

payment_id => $payment_terms->id,

sub test_default_invoice_two_items_19_7_tax_with_skonto_tax_included() {

reset_state() if $ALWAYS_RESET;

taxincluded => 1,

invoiceitems => [ $item1, $item2 ],

payment_id => $payment_terms->id,

sub test_default_invoice_two_items_19_7_without_skonto() {

reset_state() if $ALWAYS_RESET;

taxincluded => 0,

invoiceitems => [ $item1, $item2 ],

payment_id => $payment_terms->id,

sub test_default_invoice_two_items_19_7_without_skonto_incomplete_payment() {

reset_state() if $ALWAYS_RESET;

taxincluded => 0,

invoiceitems => [ $item1, $item2 ],

payment_id => $payment_terms->id,

sub test_default_invoice_two_items_19_7_tax_without_skonto_multiple_payments() {

reset_state() if $ALWAYS_RESET;

taxincluded => 0,

invoiceitems => [ $item1, $item2 ],

payment_id => $payment_terms->id,

sub test_default_invoice_two_items_19_7_tax_without_skonto_multiple_payments_final_difference_as_skonto() {

reset_state() if $ALWAYS_RESET;

taxincluded => 0,

invoiceitems => [ $item1, $item2 ],

payment_id => $payment_terms->id,

# (11.66) rather than the 19% account (5.85). The actual tax amount is

# higher for the 19% case, though (1.11 compared to 0.82)

taxincluded => 0,

invoiceitems => [ $item1, $item2 ],

payment_id => $payment_terms->id,

reset_state() if $ALWAYS_RESET;

# if there are two cents left there will be two skonto bookings, 1 cent each

taxincluded => 0,

invoiceitems => [ $item1, $item2 ],

payment_id => $payment_terms->id,

sub test_default_invoice_one_item_19_multiple_payment_final_difference_as_skonto() {

reset_state() if $ALWAYS_RESET;

taxincluded => 0,

invoiceitems => [ $item ],

payment_id => $payment_terms->id,

sub test_default_invoice_one_item_19_multiple_payment_final_difference_as_skonto_1cent() {

reset_state() if $ALWAYS_RESET;

taxincluded => 0,

invoiceitems => [ $item ],

payment_id => $payment_terms->id,

sub test_default_invoice_two_items_19_7_tax_with_skonto_50_50() {

reset_state() if $ALWAYS_RESET;

taxincluded => 0,

invoiceitems => [ $item1, $item2 ],

payment_id => $payment_terms->id,

sub test_default_invoice_four_items_19_7_tax_with_skonto_4x_25() {

reset_state() if $ALWAYS_RESET;

taxincluded => 0,

invoiceitems => [ $item1, $item2, $item3, $item4 ],

payment_id => $payment_terms->id,

sub test_default_invoice_four_items_19_7_tax_with_skonto_4x_25_tax_included() {

reset_state() if $ALWAYS_RESET;

taxincluded => 1,

invoiceitems => [ $item1, $item2, $item3, $item4 ],

payment_id => $payment_terms->id,

sub test_default_invoice_four_items_19_7_tax_with_skonto_4x_25_multiple() {

reset_state() if $ALWAYS_RESET;

taxincluded => 0,

invoiceitems => [ $item1, $item2, $item3, $item4 ],

payment_id => $payment_terms->id,

sub test_credit_note_two_items_19_7_tax_tax_not_included() {

reset_state() if $ALWAYS_RESET;

invnumber => 'cn1',

taxincluded => 0,

invoiceitems => [ $item1, $item2 ],

use List::MoreUtils qw(uniq);

use Support::TestSetup;

use Test::Exception;

use SL::DB::Buchungsgruppe;

use SL::DB::Currency;

$tax7 = SL::DB::Manager::Tax->find_by(taxkey => 2, rate => 0.07) || croak "No tax for 7\%";

$taxzone = SL::DB::Manager::TaxZone->find_by( description => 'Inland') || croak "No taxzone";

name => 'Test Customer',

taxzone_id => $taxzone->id,

%{ $params{customer} }

)->save;

@parts = ();

partnumber => 'T4254',

description => 'Fourty-two fifty-four',

lastcost => 1.93,

%{ $params{part1} }

)->save;

partnumber => 'T0815',

description => 'Zero EIGHT fifteeN @ 7%',

lastcost => 5.473,

%{ $params{part2} }

)->save;

partnumber => 'T888',

description => 'Triple 8',

lastcost => 0,

sub new_invoice {

my %params = @_;

taxzone_id => $taxzone->id,

%params,

);

my $part = delete($params{part}) || $parts[0];

part => $part,

%params,

);

use Data::Dumper;

use Support::TestSetup;

use SL::DB::Part;

Support::TestSetup::login();

# test simple transaction

SL::DB->client->with_transaction(sub {

$part->save;

ok 1, 'part saved';

};

# test failing transaction

SL::DB->client->with_transaction(sub {

$part2->save;

ok 0, 'part saved';

# TODO - not possible to test without locally adding hooks in run time

# test if error gets correctly stored in db->error

SL::DB->client->with_transaction(sub {

$part2->save;

ok 0, 'part saved';

use Support::TestSetup;

use Test::Exception;

use SL::File;

Support::TestSetup::login();

clear_up();

reset_state();

ok( $file1->file_name eq 'file1' ,"file has right name");

my $content1 = $file1->get_content;

ok( $$content1 eq 'inhalt1 uploaded' ,"file has right content");

my $content2 = File::Slurp::read_file($scannerfile);

ok( $content2 eq 'inhalt2 scanned' ,"scanned file has right content");

is( scalar( @file5), 1, "one actual file found");

my $content5 = $file5[0]->get_content();

ok( $$content5 eq 'inhalt3 new version' ,"file has right actual content");

is( scalar( @file6), 2,"two file versions found");

$content5 = $file6[0]->get_content;

ok( $$content5 eq 'inhalt3 new version' ,"file has right actual content");

sub clear_up {

# Cleaning up may fail.

eval {

unlink($scannerfile);

};

}

use SL::DB::Bin;

use SL::WH;

use SL::AM;

use SL::Helper::ShippedQty;

use DateTime;

my ($customer, $vendor, @parts, $unit);

my $default_sellprice = 10;

my $default_lastcost = 4;

my $bin1 = SL::DB::Manager::Bin->find_by(description => "Bin 1");

my $bin2 = SL::DB::Manager::Bin->find_by(description => "Bin 2");

# create 3 parts to be used in test

for my $i ( 1 .. 4 ) {

};

my $part1 = SL::DB::Manager::Part->find_by( partnumber => '1' );

note("testing purchases, no fill_up");

save => 1,

]

);

ok(!$purchase_order->items_sorted->[0]->{delivered}, "require_stock_out => 1: first purchase orderitem is not delivered");

# ship items from delivery order

Rose::DB::Object::Helpers::forget_related($purchase_order, 'orderitems');

$purchase_order->orderitems;

note('testing sales, no fill_up');

save => 1,

]

);

ok(!$sales_order->items_sorted->[0]->{delivered}, "require_stock_out => 1: first sales orderitem is not delivered");

# ship items from delivery order

Rose::DB::Object::Helpers::forget_related($sales_order, 'orderitems');

$sales_order->orderitems;

use SL::DB::Unit;

use SL::DB::Part;

use SL::DB::Assembly;

use SL::DB::Helper::ValidateAssembly;

Support::TestSetup::login();

my $retval = validate_assembly($assembly_part,$assembly2_part);

ok(!defined $retval, 'assembly 19000 can be child of assembly 20000' );

$assembly2_part->add_assemblies(SL::DB::Assembly->new(parts_id => $assembly_part->id, qty => 3, bom => 1));

$assembly2_part->save;

$retval = validate_assembly($assembly3_part,$assembly_part);

ok(!defined $retval, 'assembly 30000 can be child of assembly 19000' );

sub reset_state {

my %params = @_;

};

1;

use Carp;

use Test::Exception;

use SL::DB::Part;

Support::TestSetup::login();

clear_up();

)->save;

is( SL::DB::Manager::Part->get_all_count(), 11, "total number of parts created is 11");

use Carp;

use Test::Exception;

use SL::DB::Part;

Support::TestSetup::login();

clear_up();

warehouse_description => 'Testlager',

bin_description => 'Testlagerplatz',

number_of_bins => 2,

);

my $bin1_2 = $wh1->bins->[1];

warehouse_description => 'Testlager 2',

bin_description => 'Testlagerplatz 2',

number_of_bins => 2,

my $today = DateTime->today;

my $yesterday = $today->clone->add(days => -1);

is( SL::DB::Manager::Part->get_all_count(), 1, "total number of parts created is 1");

is( $part->get_stock == 27 , 1 , "total stock of part is 27");

use lib 't';

use_ok 'Support::TestSetup';

use_ok 'SL::DB::Bin';

SL::DB::Manager::Warehouse->delete_all(where => [ description => NAME() ]);

# Create test data

is(ref($part), 'SL::DB::Part', 'loading a part to test with id ' . $part->id);