Attachment #175018 for bug #38547

View | Details | Raw Unified | Return to bug 38547
Collapse All | Expand All




package Koha::Acquisition::MarcOrder;

# Copyright 2023, PTFS-Europe Ltd
#


use Modern::Perl;
use Try::Tiny qw( catch try );
use Net::FTP;

use base qw(Koha::Object);



=head1 NAME

Koha::Acquisition::MarcOrder - Koha Marc Order Object class

=head1 API



=head3 create_order_lines_from_file

    my $result = Koha::Acquisition::MarcOrder->create_order_lines_from_file($args);

    Controller for file staging, basket creation and order line creation when using the cronjob in marc_ordering_process.pl



=head3 import_record_and_create_order_lines

    my $result = Koha::Acquisition::MarcOrder->import_record_and_create_order_lines($args);

    Controller for record import and order line creation when using the interface in addorderiso2709.pl



=head3 match_file_to_account

    my $file_match = Koha::Acquisition::MarcOrder->match_file_to_account({
        filename => $filename,
        filepath => $filepath,
        profile  => $profile


Fetches import batches matching the batch to be added to the basket and returns these to the template

Koha::Acquisition::MarcOrder->import_batches_list();

=cut


For an import batch, this function reads the files and creates all the relevant data pertaining to that file
It then returns this to the template to be shown in the UI

Koha::Acquisition::MarcOrder->import_biblios_list( $cgiparams->{'import_batch_id'} );

=cut


Lines 1-4 Link Here

(-)a/Koha/MarcOrderAccount.pm (-2 / +2 lines)
1	package Koha::MarcOrderAccount;	1	package Koha::Acquisition::MarcOrderAccount;
2		2
3	# This file is part of Koha.	3	# This file is part of Koha.
4	#	4	#
Lines 23-29 use base qw(Koha::Object); Link Here
23		23
24	=head1 NAME	24	=head1 NAME
25		25
26	Koha::MarcOrderAccount - Koha Marc Ordering Account Object class	26	Koha::Acquisition::MarcOrderAccount - Koha Marc Ordering Account Object class
27		27
28	=head1 API	28	=head1 API
29		29




package Koha::Acquisition::MarcOrderAccounts;

# This file is part of Koha.
#

use Modern::Perl;

use Koha::Database;
use Koha::Acquisition::MarcOrderAccount;

use base qw(Koha::Objects);

=head1 NAME

Koha::Acquisition::MarcOrderAccount - Koha Marc Ordering Account Object class

=head1 API


=cut

sub object_class {
    return 'Koha::Acquisition::MarcOrderAccount';
}

1;




use Koha::ImportBatches;
use Koha::Import::Records;
use Koha::Patrons;
use Koha::Acquisition::MarcOrder;

my $input = CGI->new;
my ( $template, $loggedinuser, $cookie, $userflags ) = get_template_and_user(

    $template->param( "basketno" => $cgiparams->{'basketno'} );

    #display batches
    my $batches_list = Koha::Acquisition::MarcOrder->import_batches_list();
    $template->param(
        batch_list => $batches_list->{list},
        num_results => $batches_list->{num_results}

        bookseller => $bookseller,
        "allmatch" => $allmatch,
    );
    my $biblios_list = Koha::Acquisition::MarcOrder->import_biblios_list( $cgiparams->{'import_batch_id'} );
    my $overlay_action = $biblios_list->{overlay_action};
    my $nomatch_action = $biblios_list->{nomatch_action};
    my $item_action    = $biblios_list->{item_action};

            vendor                    => $bookseller,
            budget_id                 => $budget_id,
        };
        my $result = Koha::Acquisition::MarcOrder->import_record_and_create_order_lines($args);

        $duplinbatch = $result->{duplicates_in_batch} if $result->{duplicates_in_batch};
        next if $result->{skip};    # If a duplicate is found, or the import record wasn't selected it will be skipped





use Koha::UploadedFiles;
use Koha::ImportBatchProfiles;
use Koha::Acquisition::MarcOrder;
use Koha::Acquisition::Booksellers;
use Koha::Acquisition::MarcOrderAccount;
use Koha::Acquisition::MarcOrderAccounts;

my $input = CGI->new;



}

$template->param( messages => \@messages, op => $op);

output_html_with_http_headers $input, $cookie, $template->output;

sub show_account {
    my ( $input, $template ) = @_;
    my $acct_id = $input->param('id');
    if ($acct_id) {
        my $acct = Koha::Acquisition::MarcOrderAccounts->find($acct_id);
        if ($acct) {
            my $vendor = Koha::Acquisition::Booksellers->find( $acct->vendor_id );
            $template->param( vendor => $vendor, account => $acct );




use File::Copy   qw( copy move );

use Koha::Script -cron;
use Koha::Acquisition::MarcOrder;
use Koha::Acquisition::MarcOrderAccounts;

use C4::Log qw( cronlogaction );


print "Test run only\n" unless $confirm;

print "Fetching marc ordering accounts\n" if $verbose;
my @accounts = Koha::Acquisition::MarcOrderAccounts->search(
    {},
    { join => [ 'vendor', 'budget' ] }
)->as_list;

            agent    => 'cron'
        };
        if ( $acct->match_field && $acct->match_value ) {
            my $file_match = Koha::Acquisition::MarcOrder->match_file_to_account($args);
            next if !$file_match;
        }
        if ($confirm) {
            say sprintf "Creating order lines from file %s", $filename if $verbose;

            my $result = Koha::Acquisition::MarcOrder->create_order_lines_from_file($args);
            if ( $result->{success} ) {
                $files_processed++;
                say sprintf "Successfully processed file: %s", $filename if $verbose;





use Modern::Perl;

use Test::More tests => 9;

use Koha::Acquisition::MarcOrder;
use Koha::Acquisition::MarcOrderAccount;
use Koha::Acquisition::Baskets;
use Koha::Acquisition::Bookseller;
use MARC::Record;

    );

    my $marc_item_fields_to_order = @{
        Koha::Acquisition::MarcOrder::_get_syspref_mappings(
            $record, 'MarcItemFieldsToOrder',
        )
    }[0];

        [ '975', ' ', ' ', p => 10, q => 1, h => 1 ],
    );

    my $marc_fields_to_order = Koha::Acquisition::MarcOrder::_get_syspref_mappings(
        $record, 'MarcFieldsToOrder',
    );


    my $import_record_id = C4::ImportBatch::AddBiblioToBatch( $import_batch_id, 0, $record, 'utf8', 0 );
    my $import_record    = Koha::Import::Records->find($import_record_id);

    my $result = Koha::Acquisition::MarcOrder::add_biblio_from_import_record(
        {
            import_record   => $import_record,
            matcher_id      => $sample_import_batch->{matcher_id},

    # Check that records are skipped if not selected when called from addorderiso2709.pl
    # Pass in an empty array and the record should be skipped
    my @import_record_id_selected = ();
    my $result2                   = Koha::Acquisition::MarcOrder::add_biblio_from_import_record(
        {
            import_record             => $import_record,
            matcher_id                => $sample_import_batch->{matcher_id},

        {
            budget_period_startdate => '2008-01-01', budget_period_enddate => '2008-12-31'
            , budget_period_active      => 1
            # , budget_period_description => "MAPERI"
        }
    );
    my $budgetid = C4::Budgets::AddBudget(

    my $import_record             = Koha::Import::Records->find($import_record_id);
    my @import_record_id_selected = ($import_record_id);

    my $result = Koha::Acquisition::MarcOrder::add_biblio_from_import_record(
        {
            import_record             => $import_record,
            matcher_id                => $sample_import_batch->{matcher_id},

        'enumchrons'                => []
    };

    my $itemnumbers = Koha::Acquisition::MarcOrder::add_items_from_import_record(
        {
            record_result      => $result->{record_result},
            basket_id          => $basket->basketno,


    close $fh;

    my $account1 = Koha::Acquisition::MarcOrderAccount->new(
        {
            match_field => '975$p',
            match_value => '12345',

        }
    )->store;

    my $file_match = Koha::Acquisition::MarcOrder->match_file_to_account(
        {
            filename => $name,
            filepath => $name,


    is( $file_match, 1, 'File matched correctly to the account' );

    my $account2 = Koha::Acquisition::MarcOrderAccount->new(
        {
            match_field => '975$p',
            match_value => 'abcde',

        }
    )->store;

    my $file_match2 = Koha::Acquisition::MarcOrder->match_file_to_account(
        {
            filename => $name,
            filepath => $name,


    $schema->storage->txn_rollback;
};

subtest '_create_basket_for_file' => sub {
    plan tests => 2;

    $schema->storage->txn_begin;

    my $bookseller = Koha::Acquisition::Bookseller->new(
        {
            name         => "my vendor",
            address1     => "bookseller's address",
            phone        => "0123456",
            active       => 1,
            deliverytime => 5,
        }
    )->store;

    my $basket_count = Koha::Acquisition::Baskets->count;

    my $basketno = Koha::Acquisition::MarcOrder::_create_basket_for_file(
        {
            filename  => 'test_marc_file.marcxml',
            vendor_id => $bookseller->id,
        }
    );

    my $new_basket_count = Koha::Acquisition::Baskets->count;

    is( $new_basket_count, $basket_count + 1, 'Basket was successfully created' );

    my $basket = Koha::Acquisition::Baskets->find($basketno);

    is( $basket->basketname, 'test_marc_file.marcxml', 'Basket was successfully created' );

    $schema->storage->txn_rollback;
};

subtest 'parse_input_into_order_line_fields' => sub {
    plan tests => 8;

    $schema->storage->txn_begin;

    my $bpid = C4::Budgets::AddBudgetPeriod(
        {
            budget_period_startdate => '2008-01-01', budget_period_enddate => '2008-12-31'
            , budget_period_active => 1
        }
    );
    my $budgetid = C4::Budgets::AddBudget(
        {
            budget_code      => "BC_1",
            budget_name      => "budget_name_test_1",
            budget_period_id => $bpid,
        }
    );
    my $budgetid2 = C4::Budgets::AddBudget(
        {
            budget_code      => "BC_2",
            budget_name      => "budget_name_test_2",
            budget_period_id => $bpid,
        }
    );
    my $fund1         = C4::Budgets::GetBudget($budgetid);
    my $fund2         = C4::Budgets::GetBudget($budgetid2);
    my $budget_code_1 = $fund1->{budget_code};
    my $budget_code_2 = $fund2->{budget_code};

    my $order_line_fields = Koha::Acquisition::MarcOrder::parse_input_into_order_line_fields(
        {
            agent        => 'cron',
            biblionumber => 1,
            budget_id    => 100,
            basket_id    => 101,
            fields       => {
                quantity        => 2,
                c_quantity      => 1,
                homebranches    => [ 1, 2 ],
                holdingbranches => undef,
                budget_codes    => [ $budget_code_1, $budget_code_2 ],
            }
        }
    );

    is(
        $order_line_fields->{loop_limit}, 2,
        "Quantity has been read correctly"
    );
    is( scalar( @{ $order_line_fields->{homebranch} } ),    2, "Home branches have been read correctly" );
    is( @{ $order_line_fields->{homebranch} }[0],           1, "Home branches has been read correctly" );
    is( scalar( @{ $order_line_fields->{holdingbranch} } ), 0, "Holding branches have been read correctly" );
    is( scalar( @{ $order_line_fields->{budget_code} } ),   2, "Budget codes have been read correctly" );
    is( @{ $order_line_fields->{budget_code} }[0],          $budget_code_1, "Budget codes has been read correctly" );

    # Test with no budget codes to check account budget_id assigned correctly
    $order_line_fields = Koha::Acquisition::MarcOrder::parse_input_into_order_line_fields(
        {
            agent        => 'cron',
            biblionumber => 1,
            budget_id    => 100,
            basket_id    => 101,
            fields       => {
                quantity        => 2,
                c_quantity      => 1,
                homebranches    => [ 1, 2 ],
                holdingbranches => undef,
                budget_codes    => [],
            }
        }
    );

    is( scalar( @{ $order_line_fields->{budget_code} } ), 2,   "Budget codes have been read correctly" );
    is( @{ $order_line_fields->{budget_code} }[0],        100, "Budget codes has been read correctly" );

    $schema->storage->txn_rollback;
};

subtest 'create_items_and_generate_order_hash' => sub {
    plan tests => 6;

    $schema->storage->txn_begin;

    my $bpid = C4::Budgets::AddBudgetPeriod(
        {
            budget_period_startdate => '2008-01-01', budget_period_enddate => '2008-12-31'
            , budget_period_active => 1
        }
    );
    my $budgetid = C4::Budgets::AddBudget(
        {
            budget_code      => "BC_1",
            budget_name      => "budget_name_test_1",
            budget_period_id => $bpid,
        }
    );
    my $budgetid2 = C4::Budgets::AddBudget(
        {
            budget_code      => "BC_2",
            budget_name      => "budget_name_test_2",
            budget_period_id => $bpid,
        }
    );
    my $fund1         = C4::Budgets::GetBudget($budgetid);
    my $fund2         = C4::Budgets::GetBudget($budgetid2);
    my $budget_id_1 = $fund1->{budget_id};
    my $budget_id_2 = $fund2->{budget_id};

    my $bookseller = Koha::Acquisition::Bookseller->new(
        {
            name         => "my vendor",
            address1     => "bookseller's address",
            phone        => "0123456",
            active       => 1,
            deliverytime => 5,
        }
    )->store;

    my $basket = $builder->build_object(
        {
            class => "Koha::Acquisition::Baskets",
            value => {
                booksellerid => $bookseller->id,
                create_items => 'ordering',
                is_standing  => 0,
                closedate    => undef
            }
        }
    );

    my $biblio = $builder->build_sample_biblio;
    my $library = $builder->build( { source => 'Branch' } );
    my $branchcode = $library->{branchcode};

    my $fields = {
        loop_limit => 2,
        budget_code => [ $budget_id_1, $budget_id_2 ],
        budget_id => $budget_id_1,
        basket_id => $basket->basketno,
        biblionumber => $biblio->biblionumber,
        homebranch => [ $branchcode, $branchcode ],
        price => [ 10, 8 ],
    };

    t::lib::Mocks::mock_preference(
        'AcqCreateItem', 'ordering'
    );

    my $items_count = Koha::Items->count;
    my $orders_count = Koha::Acquisition::Orders->count;

    my $order_line_details = Koha::Acquisition::MarcOrder::create_items_and_generate_order_hash(
        {
            agent        => 'cron',
            fields       => $fields,
            vendor       => $bookseller,
            active_currency => Koha::Acquisition::Currencies->get_active,
        }
    );
    my $new_items_count = Koha::Items->count;
    my $new_orders_count = Koha::Acquisition::Orders->count;

    is( $new_items_count, $items_count + 2, 'Items were successfully created' );
    is( $new_orders_count, $orders_count + 2, 'Orders were successfully created' );

    my @items = Koha::Items->search( { biblionumber => $biblio->biblionumber } )->as_list;

    foreach my $item (@items) {
        is( $item->homebranch, $branchcode, 'Item was created in correct branch' );
    }

    my @orderlines = sort { $a->budget_id <=> $b->budget_id } Koha::Acquisition::Orders->search( { biblionumber => $biblio->biblionumber } )->as_list;

    for( my $i = 0; $i < (scalar(@orderlines)); $i++ ) {
        is( $orderlines[$i]->budget_id, @{$fields->{budget_code}}[$i], 'Orderline was created with correct budget' );
    }

    $schema->storage->txn_rollback;
};

subtest '_create_item_fields_from_syspref' => sub {
    plan tests => 4;

    $schema->storage->txn_begin;

    t::lib::Mocks::mock_preference(
        'MarcItemFieldsToOrder', 'homebranch: 975$a
holdingbranch: 975$b
itype: 975$y
nonpublic_note: 975$x
public_note: 975$z
loc: 975$c
ccode: 975$8
notforloan: 975$7
uri: 975$u
copyno: 975$n
quantity: 975$q
budget_code: 975$h
price: 975$p
replacementprice: 975$v'
    );

    t::lib::Mocks::mock_preference(
        'MarcFieldsToOrder', 'price: 949$p
quantity: 949$q
budget_code: 949$h'
    );

    my $record = MARC::Record->new();

    $record->add_fields(
        [ '001', '1234' ],
        [
            '975', ' ', ' ', p => 10, q => 1, h => 1, a => 'CPL', b => 'CPL', y => 'Book',
            x => 'Private note', z => 'Public note', c => 'Shelf', 8 => 'ccode', 7 => 0,
            u => '12345abcde',   n => '12345',       v => 10
        ],
    );
    $record->add_fields(
        [ '001', '1234' ],

        [ '949', ' ', ' ', p => 10, q => 1, h => 1 ],
    );

    my $marc_item_fields_to_order = Koha::Acquisition::MarcOrder::_get_syspref_mappings(
        $record, 'MarcItemFieldsToOrder',
        );

        my $marc_fields_to_order = Koha::Acquisition::MarcOrder::_get_syspref_mappings(
        $record, 'MarcFieldsToOrder',
        );

    my $item_fields = Koha::Acquisition::MarcOrder::_create_item_fields_from_syspref(
        {
            marc_fields_to_order      => $marc_fields_to_order,
            marc_item_fields_to_order => $marc_item_fields_to_order
        }
    );

    is(
        @{$item_fields->{itemprices}}[0], 10,
        "Price has been read correctly"
    );
    is(
        @{$item_fields->{itypes}}[0], "Book",
        "Itypes has been read correctly"
    );
    is($item_fields->{quantity}, 1, "Quantity has been read correctly");
    is($item_fields->{c_price}, 10, "MarcFieldsToOrder price has been read correctly");

    $schema->storage->txn_rollback;

}


Return to bug 38547

Lines 1-4 Link Here

(-)a/Koha/MarcOrder.pm (-8 / +7 lines)
1	package Koha::MarcOrder;	1	package Koha::Acquisition::MarcOrder;
2		2
3	# Copyright 2023, PTFS-Europe Ltd	3	# Copyright 2023, PTFS-Europe Ltd
4	#	4	#
Lines 19-25 package Koha::MarcOrder; Link Here
19		19
20	use Modern::Perl;	20	use Modern::Perl;
21	use Try::Tiny qw( catch try );	21	use Try::Tiny qw( catch try );
22	use Net::FTP;
23		22
24	use base qw(Koha::Object);	23	use base qw(Koha::Object);
25		24
Lines 64-70 use Koha::Plugins; Link Here
64		63
65	=head1 NAME	64	=head1 NAME
66		65
67	Koha::MarcOrder - Koha Marc Order Object class	66	Koha::Acquisition::MarcOrder - Koha Marc Order Object class
68		67
69	=head1 API	68	=head1 API
70		69
Lines 74-80 Koha::MarcOrder - Koha Marc Order Object class Link Here
74		73
75	=head3 create_order_lines_from_file	74	=head3 create_order_lines_from_file
76		75
77	my $result = Koha::MarcOrder->create_order_lines_from_file($args);	76	my $result = Koha::Acquisition::MarcOrder->create_order_lines_from_file($args);
78		77
79	Controller for file staging, basket creation and order line creation when using the cronjob in marc_ordering_process.pl	78	Controller for file staging, basket creation and order line creation when using the cronjob in marc_ordering_process.pl
80		79
Lines 166-172 sub create_order_lines_from_file { Link Here
166		165
167	=head3 import_record_and_create_order_lines	166	=head3 import_record_and_create_order_lines
168		167
169	my $result = Koha::MarcOrder->import_record_and_create_order_lines($args);	168	my $result = Koha::Acquisition::MarcOrder->import_record_and_create_order_lines($args);
170		169
171	Controller for record import and order line creation when using the interface in addorderiso2709.pl	170	Controller for record import and order line creation when using the interface in addorderiso2709.pl
172		171
Lines 529-535 sub add_items_from_import_record { Link Here
529		528
530	=head3 match_file_to_account	529	=head3 match_file_to_account
531		530
532	my $file_match = Koha::MarcOrder->match_file_to_account({	531	my $file_match = Koha::Acquisition::MarcOrder->match_file_to_account({
533	filename => $filename,	532	filename => $filename,
534	filepath => $filepath,	533	filepath => $filepath,
535	profile => $profile	534	profile => $profile
Lines 576-582 sub match_file_to_account { Link Here
576		575
577	Fetches import batches matching the batch to be added to the basket and returns these to the template	576	Fetches import batches matching the batch to be added to the basket and returns these to the template
578		577
579	Koha::MarcOrder->import_batches_list();	578	Koha::Acquisition::MarcOrder->import_batches_list();
580		579
581	=cut	580	=cut
582		581
Lines 626-632 sub import_batches_list { Link Here
626	For an import batch, this function reads the files and creates all the relevant data pertaining to that file	625	For an import batch, this function reads the files and creates all the relevant data pertaining to that file
627	It then returns this to the template to be shown in the UI	626	It then returns this to the template to be shown in the UI
628		627
629	Koha::MarcOrder->import_biblios_list( $cgiparams->{'import_batch_id'} );	628	Koha::Acquisition::MarcOrder->import_biblios_list( $cgiparams->{'import_batch_id'} );
630		629
631	=cut	630	=cut
632		631

Lines 32-41 use C4::Matcher; Link Here

(-)a/admin/marc_order_accounts.pl (-4 / +6 lines)
32		32
33	use Koha::UploadedFiles;	33	use Koha::UploadedFiles;
34	use Koha::ImportBatchProfiles;	34	use Koha::ImportBatchProfiles;
35	use Koha::MarcOrder;	35	use Koha::Acquisition::MarcOrder;
36	use Koha::Acquisition::Booksellers;	36	use Koha::Acquisition::Booksellers;
37	use Koha::MarcOrderAccount;	37	use Koha::Acquisition::MarcOrderAccount;
38	use Koha::MarcOrderAccounts;	38	use Koha::Acquisition::MarcOrderAccounts;
39		39
40	my $input = CGI->new;	40	my $input = CGI->new;
41		41
Lines 109-121 if ( $op eq 'acct_form' ) { Link Here
109		109
110	}	110	}
111		111
		112	$template->param( messages => \@messages, op => $op);
		113
112	output_html_with_http_headers $input, $cookie, $template->output;	114	output_html_with_http_headers $input, $cookie, $template->output;
113		115
114	sub show_account {	116	sub show_account {
115	my ( $input, $template ) = @_;	117	my ( $input, $template ) = @_;
116	my $acct_id = $input->param('id');	118	my $acct_id = $input->param('id');
117	if ($acct_id) {	119	if ($acct_id) {
118	my $acct = Koha::MarcOrderAccounts->find($acct_id);	120	my $acct = Koha::Acquisition::MarcOrderAccounts->find($acct_id);
119	if ($acct) {	121	if ($acct) {
120	my $vendor = Koha::Acquisition::Booksellers->find( $acct->vendor_id );	122	my $vendor = Koha::Acquisition::Booksellers->find( $acct->vendor_id );
121	$template->param( vendor => $vendor, account => $acct );	123	$template->param( vendor => $vendor, account => $acct );

Lines 61-68 use Getopt::Long qw( GetOptions ); Link Here

(-)a/misc/cronjobs/marc_ordering_process.pl (-5 / +5 lines)
61	use File::Copy qw( copy move );	61	use File::Copy qw( copy move );
62		62
63	use Koha::Script -cron;	63	use Koha::Script -cron;
64	use Koha::MarcOrder;	64	use Koha::Acquisition::MarcOrder;
65	use Koha::MarcOrderAccounts;	65	use Koha::Acquisition::MarcOrderAccounts;
66		66
67	use C4::Log qw( cronlogaction );	67	use C4::Log qw( cronlogaction );
68		68
Lines 84-90 $verbose = 1 unless $verbose or $confirm; Link Here
84	print "Test run only\n" unless $confirm;	84	print "Test run only\n" unless $confirm;
85		85
86	print "Fetching marc ordering accounts\n" if $verbose;	86	print "Fetching marc ordering accounts\n" if $verbose;
87	my @accounts = Koha::MarcOrderAccounts->search(	87	my @accounts = Koha::Acquisition::MarcOrderAccounts->search(
88	{},	88	{},
89	{ join => [ 'vendor', 'budget' ] }	89	{ join => [ 'vendor', 'budget' ] }
90	)->as_list;	90	)->as_list;
Lines 116-128 foreach my $acct (@accounts) { Link Here
116	agent => 'cron'	116	agent => 'cron'
117	};	117	};
118	if ( $acct->match_field && $acct->match_value ) {	118	if ( $acct->match_field && $acct->match_value ) {
119	my $file_match = Koha::MarcOrder->match_file_to_account($args);	119	my $file_match = Koha::Acquisition::MarcOrder->match_file_to_account($args);
120	next if !$file_match;	120	next if !$file_match;
121	}	121	}
122	if ($confirm) {	122	if ($confirm) {
123	say sprintf "Creating order lines from file %s", $filename if $verbose;	123	say sprintf "Creating order lines from file %s", $filename if $verbose;
124		124
125	my $result = Koha::MarcOrder->create_order_lines_from_file($args);	125	my $result = Koha::Acquisition::MarcOrder->create_order_lines_from_file($args);
126	if ( $result->{success} ) {	126	if ( $result->{success} ) {
127	$files_processed++;	127	$files_processed++;
128	say sprintf "Successfully processed file: %s", $filename if $verbose;	128	say sprintf "Successfully processed file: %s", $filename if $verbose;

Lines 1-4 Link Here

(-)a/Koha/MarcOrderAccounts.pm (-4 / +4 lines)
1	package Koha::MarcOrderAccounts;	1	package Koha::Acquisition::MarcOrderAccounts;
2		2
3	# This file is part of Koha.	3	# This file is part of Koha.
4	#	4	#
Lines 18-30 package Koha::MarcOrderAccounts; Link Here
18	use Modern::Perl;	18	use Modern::Perl;
19		19
20	use Koha::Database;	20	use Koha::Database;
21	use Koha::MarcOrderAccount;	21	use Koha::Acquisition::MarcOrderAccount;
22		22
23	use base qw(Koha::Objects);	23	use base qw(Koha::Objects);
24		24
25	=head1 NAME	25	=head1 NAME
26		26
27	Koha::MarcOrderAccount - Koha Marc Ordering Account Object class	27	Koha::Acquisition::MarcOrderAccount - Koha Marc Ordering Account Object class
28		28
29	=head1 API	29	=head1 API
30		30
Lines 45-51 sub _type { Link Here
45	=cut	45	=cut
46		46
47	sub object_class {	47	sub object_class {
48	return 'Koha::MarcOrderAccount';	48	return 'Koha::Acquisition::MarcOrderAccount';
49	}	49	}
50		50
51	1;	51	1;

Lines 54-60 use Koha::Acquisition::Booksellers; Link Here

(-)a/acqui/addorderiso2709.pl (-4 / +4 lines)
54	use Koha::ImportBatches;	54	use Koha::ImportBatches;
55	use Koha::Import::Records;	55	use Koha::Import::Records;
56	use Koha::Patrons;	56	use Koha::Patrons;
57	use Koha::MarcOrder;	57	use Koha::Acquisition::MarcOrder;
58		58
59	my $input = CGI->new;	59	my $input = CGI->new;
60	my ( $template, $loggedinuser, $cookie, $userflags ) = get_template_and_user(	60	my ( $template, $loggedinuser, $cookie, $userflags ) = get_template_and_user(
Lines 95-101 if ( $op eq "" ) { Link Here
95	$template->param( "basketno" => $cgiparams->{'basketno'} );	95	$template->param( "basketno" => $cgiparams->{'basketno'} );
96		96
97	#display batches	97	#display batches
98	my $batches_list = Koha::MarcOrder->import_batches_list();	98	my $batches_list = Koha::Acquisition::MarcOrder->import_batches_list();
99	$template->param(	99	$template->param(
100	batch_list => $batches_list->{list},	100	batch_list => $batches_list->{list},
101	num_results => $batches_list->{num_results}	101	num_results => $batches_list->{num_results}
Lines 116-122 if ( $op eq "" ) { Link Here
116	bookseller => $bookseller,	116	bookseller => $bookseller,
117	"allmatch" => $allmatch,	117	"allmatch" => $allmatch,
118	);	118	);
119	my $biblios_list = Koha::MarcOrder->import_biblios_list( $cgiparams->{'import_batch_id'} );	119	my $biblios_list = Koha::Acquisition::MarcOrder->import_biblios_list( $cgiparams->{'import_batch_id'} );
120	my $overlay_action = $biblios_list->{overlay_action};	120	my $overlay_action = $biblios_list->{overlay_action};
121	my $nomatch_action = $biblios_list->{nomatch_action};	121	my $nomatch_action = $biblios_list->{nomatch_action};
122	my $item_action = $biblios_list->{item_action};	122	my $item_action = $biblios_list->{item_action};
Lines 281-287 if ( $op eq "" ) { Link Here
281	vendor => $bookseller,	281	vendor => $bookseller,
282	budget_id => $budget_id,	282	budget_id => $budget_id,
283	};	283	};
284	my $result = Koha::MarcOrder->import_record_and_create_order_lines($args);	284	my $result = Koha::Acquisition::MarcOrder->import_record_and_create_order_lines($args);
285		285
286	$duplinbatch = $result->{duplicates_in_batch} if $result->{duplicates_in_batch};	286	$duplinbatch = $result->{duplicates_in_batch} if $result->{duplicates_in_batch};
287	next if $result->{skip}; # If a duplicate is found, or the import record wasn't selected it will be skipped	287	next if $result->{skip}; # If a duplicate is found, or the import record wasn't selected it will be skipped

Lines 17-26 Link Here

(-)a/t/db_dependent/Koha/MarcOrder.t (-15 / +305 lines)
17		17
18	use Modern::Perl;	18	use Modern::Perl;
19		19
20	use Test::More tests => 5;	20	use Test::More tests => 9;
21		21
22	use Koha::MarcOrder;	22	use Koha::Acquisition::MarcOrder;
23	use Koha::MarcOrderAccount;	23	use Koha::Acquisition::MarcOrderAccount;
24	use Koha::Acquisition::Baskets;	24	use Koha::Acquisition::Baskets;
25	use Koha::Acquisition::Bookseller;	25	use Koha::Acquisition::Bookseller;
26	use MARC::Record;	26	use MARC::Record;
Lines 71-77 replacementprice: 975$v' Link Here
71	);	71	);
72		72
73	my $marc_item_fields_to_order = @{	73	my $marc_item_fields_to_order = @{
74	Koha::MarcOrder::_get_syspref_mappings(	74	Koha::Acquisition::MarcOrder::_get_syspref_mappings(
75	$record, 'MarcItemFieldsToOrder',	75	$record, 'MarcItemFieldsToOrder',
76	)	76	)
77	}[0];	77	}[0];
Lines 154-160 budget_code: 975$h' Link Here
154	[ '975', ' ', ' ', p => 10, q => 1, h => 1 ],	154	[ '975', ' ', ' ', p => 10, q => 1, h => 1 ],
155	);	155	);
156		156
157	my $marc_fields_to_order = Koha::MarcOrder::_get_syspref_mappings(	157	my $marc_fields_to_order = Koha::Acquisition::MarcOrder::_get_syspref_mappings(
158	$record, 'MarcFieldsToOrder',	158	$record, 'MarcFieldsToOrder',
159	);	159	);
160		160
Lines 206-212 subtest 'add_biblio_from_import_record()' => sub { Link Here
206	my $import_record_id = C4::ImportBatch::AddBiblioToBatch( $import_batch_id, 0, $record, 'utf8', 0 );	206	my $import_record_id = C4::ImportBatch::AddBiblioToBatch( $import_batch_id, 0, $record, 'utf8', 0 );
207	my $import_record = Koha::Import::Records->find($import_record_id);	207	my $import_record = Koha::Import::Records->find($import_record_id);
208		208
209	my $result = Koha::MarcOrder::add_biblio_from_import_record(	209	my $result = Koha::Acquisition::MarcOrder::add_biblio_from_import_record(
210	{	210	{
211	import_record => $import_record,	211	import_record => $import_record,
212	matcher_id => $sample_import_batch->{matcher_id},	212	matcher_id => $sample_import_batch->{matcher_id},
Lines 224-230 subtest 'add_biblio_from_import_record()' => sub { Link Here
224	# Check that records are skipped if not selected when called from addorderiso2709.pl	224	# Check that records are skipped if not selected when called from addorderiso2709.pl
225	# Pass in an empty array and the record should be skipped	225	# Pass in an empty array and the record should be skipped
226	my @import_record_id_selected = ();	226	my @import_record_id_selected = ();
227	my $result2 = Koha::MarcOrder::add_biblio_from_import_record(	227	my $result2 = Koha::Acquisition::MarcOrder::add_biblio_from_import_record(
228	{	228	{
229	import_record => $import_record,	229	import_record => $import_record,
230	matcher_id => $sample_import_batch->{matcher_id},	230	matcher_id => $sample_import_batch->{matcher_id},
Lines 254-260 subtest 'add_items_from_import_record() - addorderiso2709.pl' => sub { Link Here
254	{	254	{
255	budget_period_startdate => '2008-01-01', budget_period_enddate => '2008-12-31'	255	budget_period_startdate => '2008-01-01', budget_period_enddate => '2008-12-31'
256	, budget_period_active => 1	256	, budget_period_active => 1
257	, budget_period_description => "MAPERI"	257	# , budget_period_description => "MAPERI"
258	}	258	}
259	);	259	);
260	my $budgetid = C4::Budgets::AddBudget(	260	my $budgetid = C4::Budgets::AddBudget(
Lines 304-310 subtest 'add_items_from_import_record() - addorderiso2709.pl' => sub { Link Here
304	my $import_record = Koha::Import::Records->find($import_record_id);	304	my $import_record = Koha::Import::Records->find($import_record_id);
305	my @import_record_id_selected = ($import_record_id);	305	my @import_record_id_selected = ($import_record_id);
306		306
307	my $result = Koha::MarcOrder::add_biblio_from_import_record(	307	my $result = Koha::Acquisition::MarcOrder::add_biblio_from_import_record(
308	{	308	{
309	import_record => $import_record,	309	import_record => $import_record,
310	matcher_id => $sample_import_batch->{matcher_id},	310	matcher_id => $sample_import_batch->{matcher_id},
Lines 393-399 subtest 'add_items_from_import_record() - addorderiso2709.pl' => sub { Link Here
393	'enumchrons' => []	393	'enumchrons' => []
394	};	394	};
395		395
396	my $itemnumbers = Koha::MarcOrder::add_items_from_import_record(	396	my $itemnumbers = Koha::Acquisition::MarcOrder::add_items_from_import_record(
397	{	397	{
398	record_result => $result->{record_result},	398	record_result => $result->{record_result},
399	basket_id => $basket->basketno,	399	basket_id => $basket->basketno,
Lines 456-462 subtest 'match_file_to_account' => sub { Link Here
456		456
457	close $fh;	457	close $fh;
458		458
459	my $account1 = Koha::MarcOrderAccount->new(	459	my $account1 = Koha::Acquisition::MarcOrderAccount->new(
460	{	460	{
461	match_field => '975$p',	461	match_field => '975$p',
462	match_value => '12345',	462	match_value => '12345',
Lines 465-471 subtest 'match_file_to_account' => sub { Link Here
465	}	465	}
466	)->store;	466	)->store;
467		467
468	my $file_match = Koha::MarcOrder->match_file_to_account(	468	my $file_match = Koha::Acquisition::MarcOrder->match_file_to_account(
469	{	469	{
470	filename => $name,	470	filename => $name,
471	filepath => $name,	471	filepath => $name,
Lines 475-481 subtest 'match_file_to_account' => sub { Link Here
475		475
476	is( $file_match, 1, 'File matched correctly to the account' );	476	is( $file_match, 1, 'File matched correctly to the account' );
477		477
478	my $account2 = Koha::MarcOrderAccount->new(	478	my $account2 = Koha::Acquisition::MarcOrderAccount->new(
479	{	479	{
480	match_field => '975$p',	480	match_field => '975$p',
481	match_value => 'abcde',	481	match_value => 'abcde',
Lines 484-490 subtest 'match_file_to_account' => sub { Link Here
484	}	484	}
485	)->store;	485	)->store;
486		486
487	my $file_match2 = Koha::MarcOrder->match_file_to_account(	487	my $file_match2 = Koha::Acquisition::MarcOrder->match_file_to_account(
488	{	488	{
489	filename => $name,	489	filename => $name,
490	filepath => $name,	490	filepath => $name,
Lines 496-498 subtest 'match_file_to_account' => sub { Link Here
496		496
497	$schema->storage->txn_rollback;	497	$schema->storage->txn_rollback;
498	};	498	};
499	-	499
		500	subtest '_create_basket_for_file' => sub {
		501	plan tests => 2;
		502
		503	$schema->storage->txn_begin;
		504
		505	my $bookseller = Koha::Acquisition::Bookseller->new(
		506	{
		507	name => "my vendor",
		508	address1 => "bookseller's address",
		509	phone => "0123456",
		510	active => 1,
		511	deliverytime => 5,
		512	}
		513	)->store;
		514
		515	my $basket_count = Koha::Acquisition::Baskets->count;
		516
		517	my $basketno = Koha::Acquisition::MarcOrder::_create_basket_for_file(
		518	{
		519	filename => 'test_marc_file.marcxml',
		520	vendor_id => $bookseller->id,
		521	}
		522	);
		523
		524	my $new_basket_count = Koha::Acquisition::Baskets->count;
		525
		526	is( $new_basket_count, $basket_count + 1, 'Basket was successfully created' );
		527
		528	my $basket = Koha::Acquisition::Baskets->find($basketno);
		529
		530	is( $basket->basketname, 'test_marc_file.marcxml', 'Basket was successfully created' );
		531
		532	$schema->storage->txn_rollback;
		533	};
		534
		535	subtest 'parse_input_into_order_line_fields' => sub {
		536	plan tests => 8;
		537
		538	$schema->storage->txn_begin;
		539
		540	my $bpid = C4::Budgets::AddBudgetPeriod(
		541	{
		542	budget_period_startdate => '2008-01-01', budget_period_enddate => '2008-12-31'
		543	, budget_period_active => 1
		544	}
		545	);
		546	my $budgetid = C4::Budgets::AddBudget(
		547	{
		548	budget_code => "BC_1",
		549	budget_name => "budget_name_test_1",
		550	budget_period_id => $bpid,
		551	}
		552	);
		553	my $budgetid2 = C4::Budgets::AddBudget(
		554	{
		555	budget_code => "BC_2",
		556	budget_name => "budget_name_test_2",
		557	budget_period_id => $bpid,
		558	}
		559	);
		560	my $fund1 = C4::Budgets::GetBudget($budgetid);
		561	my $fund2 = C4::Budgets::GetBudget($budgetid2);
		562	my $budget_code_1 = $fund1->{budget_code};
		563	my $budget_code_2 = $fund2->{budget_code};
564
565	my $order_line_fields = Koha::Acquisition::MarcOrder::parse_input_into_order_line_fields(
566	{
567	agent => 'cron',
568	biblionumber => 1,
569	budget_id => 100,
570	basket_id => 101,
571	fields => {
572	quantity => 2,
573	c_quantity => 1,
574	homebranches => [ 1, 2 ],
575	holdingbranches => undef,
576	budget_codes => [ $budget_code_1, $budget_code_2 ],
577	}
578	}
579	);
580
581	is(
582	$order_line_fields->{loop_limit}, 2,
583	"Quantity has been read correctly"
584	);
585	is( scalar( @{ $order_line_fields->{homebranch} } ), 2, "Home branches have been read correctly" );
586	is( @{ $order_line_fields->{homebranch} }[0], 1, "Home branches has been read correctly" );
587	is( scalar( @{ $order_line_fields->{holdingbranch} } ), 0, "Holding branches have been read correctly" );
588	is( scalar( @{ $order_line_fields->{budget_code} } ), 2, "Budget codes have been read correctly" );
589	is( @{ $order_line_fields->{budget_code} }[0], $budget_code_1, "Budget codes has been read correctly" );
590
591	# Test with no budget codes to check account budget_id assigned correctly
592	$order_line_fields = Koha::Acquisition::MarcOrder::parse_input_into_order_line_fields(
593	{
594	agent => 'cron',
595	biblionumber => 1,
596	budget_id => 100,
597	basket_id => 101,
598	fields => {
599	quantity => 2,
600	c_quantity => 1,
601	homebranches => [ 1, 2 ],
602	holdingbranches => undef,
603	budget_codes => [],
604	}
605	}
606	);
607
608	is( scalar( @{ $order_line_fields->{budget_code} } ), 2, "Budget codes have been read correctly" );
609	is( @{ $order_line_fields->{budget_code} }[0], 100, "Budget codes has been read correctly" );
610
611	$schema->storage->txn_rollback;
612	};
613
614	subtest 'create_items_and_generate_order_hash' => sub {
615	plan tests => 6;
616
617	$schema->storage->txn_begin;
618
619	my $bpid = C4::Budgets::AddBudgetPeriod(
620	{
621	budget_period_startdate => '2008-01-01', budget_period_enddate => '2008-12-31'
622	, budget_period_active => 1
623	}
624	);
625	my $budgetid = C4::Budgets::AddBudget(
626	{
627	budget_code => "BC_1",
628	budget_name => "budget_name_test_1",
629	budget_period_id => $bpid,
630	}
631	);
632	my $budgetid2 = C4::Budgets::AddBudget(
633	{
634	budget_code => "BC_2",
635	budget_name => "budget_name_test_2",
636	budget_period_id => $bpid,
637	}
638	);
639	my $fund1 = C4::Budgets::GetBudget($budgetid);
640	my $fund2 = C4::Budgets::GetBudget($budgetid2);
641	my $budget_id_1 = $fund1->{budget_id};
642	my $budget_id_2 = $fund2->{budget_id};
643
644	my $bookseller = Koha::Acquisition::Bookseller->new(
645	{
646	name => "my vendor",
647	address1 => "bookseller's address",
648	phone => "0123456",
649	active => 1,
650	deliverytime => 5,
651	}
652	)->store;
653
654	my $basket = $builder->build_object(
655	{
656	class => "Koha::Acquisition::Baskets",
657	value => {
658	booksellerid => $bookseller->id,
659	create_items => 'ordering',
660	is_standing => 0,
661	closedate => undef
662	}
663	}
664	);
665
666	my $biblio = $builder->build_sample_biblio;
667	my $library = $builder->build( { source => 'Branch' } );
668	my $branchcode = $library->{branchcode};
669
670	my $fields = {
671	loop_limit => 2,
672	budget_code => [ $budget_id_1, $budget_id_2 ],
673	budget_id => $budget_id_1,
674	basket_id => $basket->basketno,
675	biblionumber => $biblio->biblionumber,
676	homebranch => [ $branchcode, $branchcode ],
677	price => [ 10, 8 ],
678	};
679
680	t::lib::Mocks::mock_preference(
681	'AcqCreateItem', 'ordering'
682	);
683
684	my $items_count = Koha::Items->count;
685	my $orders_count = Koha::Acquisition::Orders->count;
686
687	my $order_line_details = Koha::Acquisition::MarcOrder::create_items_and_generate_order_hash(
688	{
689	agent => 'cron',
690	fields => $fields,
691	vendor => $bookseller,
692	active_currency => Koha::Acquisition::Currencies->get_active,
693	}
694	);
695	my $new_items_count = Koha::Items->count;
696	my $new_orders_count = Koha::Acquisition::Orders->count;
697
698	is( $new_items_count, $items_count + 2, 'Items were successfully created' );
699	is( $new_orders_count, $orders_count + 2, 'Orders were successfully created' );
700
701	my @items = Koha::Items->search( { biblionumber => $biblio->biblionumber } )->as_list;
702
703	foreach my $item (@items) {
704	is( $item->homebranch, $branchcode, 'Item was created in correct branch' );
705	}
706
707	my @orderlines = sort { $a->budget_id <=> $b->budget_id } Koha::Acquisition::Orders->search( { biblionumber => $biblio->biblionumber } )->as_list;
708
709	for( my $i = 0; $i < (scalar(@orderlines)); $i++ ) {
710	is( $orderlines[$i]->budget_id, @{$fields->{budget_code}}[$i], 'Orderline was created with correct budget' );
711	}
712
713	$schema->storage->txn_rollback;
714	};
715
716	subtest '_create_item_fields_from_syspref' => sub {
717	plan tests => 4;
718
719	$schema->storage->txn_begin;
720
721	t::lib::Mocks::mock_preference(
722	'MarcItemFieldsToOrder', 'homebranch: 975$a
723	holdingbranch: 975$b
724	itype: 975$y
725	nonpublic_note: 975$x
726	public_note: 975$z
727	loc: 975$c
728	ccode: 975$8
729	notforloan: 975$7
730	uri: 975$u
731	copyno: 975$n
732	quantity: 975$q
733	budget_code: 975$h
734	price: 975$p
735	replacementprice: 975$v'
736	);
737
738	t::lib::Mocks::mock_preference(
739	'MarcFieldsToOrder', 'price: 949$p
740	quantity: 949$q
741	budget_code: 949$h'
742	);
743
744	my $record = MARC::Record->new();
745
746	$record->add_fields(
747	[ '001', '1234' ],
748	[
749	'975', ' ', ' ', p => 10, q => 1, h => 1, a => 'CPL', b => 'CPL', y => 'Book',
750	x => 'Private note', z => 'Public note', c => 'Shelf', 8 => 'ccode', 7 => 0,
751	u => '12345abcde', n => '12345', v => 10
752	],
753	);
754	$record->add_fields(
755	[ '001', '1234' ],
756
757	[ '949', ' ', ' ', p => 10, q => 1, h => 1 ],
758	);
759
760	my $marc_item_fields_to_order = Koha::Acquisition::MarcOrder::_get_syspref_mappings(
761	$record, 'MarcItemFieldsToOrder',
762	);
763
764	my $marc_fields_to_order = Koha::Acquisition::MarcOrder::_get_syspref_mappings(
765	$record, 'MarcFieldsToOrder',
766	);
767
768	my $item_fields = Koha::Acquisition::MarcOrder::_create_item_fields_from_syspref(
769	{
770	marc_fields_to_order => $marc_fields_to_order,
771	marc_item_fields_to_order => $marc_item_fields_to_order
772	}
773	);
774
775	is(
776	@{$item_fields->{itemprices}}[0], 10,
777	"Price has been read correctly"
778	);
779	is(
780	@{$item_fields->{itypes}}[0], "Book",
781	"Itypes has been read correctly"
782	);
783	is($item_fields->{quantity}, 1, "Quantity has been read correctly");
784	is($item_fields->{c_price}, 10, "MarcFieldsToOrder price has been read correctly");
785
786	$schema->storage->txn_rollback;
787
788	}
789