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