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

(-)a/C4/Acquisition.pm (-94 / +6 lines)
Lines 31-36 use C4::Debug; Link Here
31
use C4::Bookseller qw(GetBookSellerFromId);
31
use C4::Bookseller qw(GetBookSellerFromId);
32
use C4::Templates qw(gettemplate);
32
use C4::Templates qw(gettemplate);
33
use Koha::DateUtils qw( dt_from_string output_pref );
33
use Koha::DateUtils qw( dt_from_string output_pref );
34
use Koha::Acquisition::Order;
34
35
35
use Time::localtime;
36
use Time::localtime;
36
use HTML::Entities;
37
use HTML::Entities;
Lines 56-68 BEGIN { Link Here
56
        &ModBasketgroup &NewBasketgroup &DelBasketgroup &GetBasketgroup &CloseBasketgroup
57
        &ModBasketgroup &NewBasketgroup &DelBasketgroup &GetBasketgroup &CloseBasketgroup
57
        &GetBasketgroups &ReOpenBasketgroup
58
        &GetBasketgroups &ReOpenBasketgroup
58
59
59
        &NewOrder &DelOrder &ModOrder &GetOrder &GetOrders &GetOrdersByBiblionumber
60
        &DelOrder &ModOrder &GetOrder &GetOrders &GetOrdersByBiblionumber
60
        &GetLateOrders &GetOrderFromItemnumber
61
        &GetLateOrders &GetOrderFromItemnumber
61
        &SearchOrders &GetHistory &GetRecentAcqui
62
        &SearchOrders &GetHistory &GetRecentAcqui
62
        &ModReceiveOrder &CancelReceipt
63
        &ModReceiveOrder &CancelReceipt
63
        &GetCancelledOrders &TransferOrder
64
        &GetCancelledOrders &TransferOrder
64
        &GetLastOrderNotReceivedFromSubscriptionid &GetLastOrderReceivedFromSubscriptionid
65
        &GetLastOrderNotReceivedFromSubscriptionid &GetLastOrderReceivedFromSubscriptionid
65
        &NewOrderItem &ModItemOrder
66
        &ModItemOrder
66
67
67
        &GetParcels &GetParcel
68
        &GetParcels &GetParcel
68
69
Lines 1228-1322 sub GetLastOrderReceivedFromSubscriptionid { Link Here
1228
1229
1229
}
1230
}
1230
1231
1231
1232
#------------------------------------------------------------#
1233
1234
=head3 NewOrder
1235
1236
  &NewOrder(\%hashref);
1237
1238
Adds a new order to the database. Any argument that isn't described
1239
below is the new value of the field with the same name in the aqorders
1240
table of the Koha database.
1241
1242
=over
1243
1244
=item $hashref->{'basketno'} is the basketno foreign key in aqorders, it is mandatory
1245
1246
=item $hashref->{'ordernumber'} is a "minimum order number."
1247
1248
=item $hashref->{'budgetdate'} is effectively ignored.
1249
If it's undef (anything false) or the string 'now', the current day is used.
1250
Else, the upcoming July 1st is used.
1251
1252
=item $hashref->{'subscription'} may be either "yes", or anything else for "no".
1253
1254
=item $hashref->{'uncertainprice'} may be 0 for "the price is known" or 1 for "the price is uncertain"
1255
1256
=item defaults entrydate to Now
1257
1258
The following keys are used: "biblionumber", "title", "basketno", "quantity", "order_vendornote", "order_internalnote", "rrp", "ecost", "gstrate", "unitprice", "subscription", "sort1", "sort2", "booksellerinvoicenumber", "listprice", "budgetdate", "purchaseordernumber", "branchcode", "booksellerinvoicenumber", "budget_id".
1259
1260
=back
1261
1262
=cut
1263
1264
sub NewOrder {
1265
    my $orderinfo = shift;
1266
1267
    my $dbh = C4::Context->dbh;
1268
    my @params;
1269
1270
    croak "The ordernumber parameter should not be provided on calling NewOrder"
1271
      if $orderinfo->{ordernumber};
1272
1273
    # if these parameters are missing, we can't continue
1274
    for my $key ( qw( basketno quantity biblionumber budget_id ) ) {
1275
        croak "Cannot insert order: Mandatory parameter $key is missing" unless $orderinfo->{$key};
1276
    }
1277
1278
    $orderinfo->{quantityreceived} ||= 0;
1279
    $orderinfo->{entrydate} ||= output_pref({ dt => dt_from_string, dateformat => 'iso'});
1280
1281
    # get only the columns of Aqorder
1282
    my $schema = Koha::Database->new()->schema;
1283
    my $columns = ' '.join(' ', $schema->source('Aqorder')->columns).' ';
1284
    my $new_order = { map { $columns =~ / $_ / ? ($_ => $orderinfo->{$_}) : () } keys(%$orderinfo) };
1285
    $new_order->{ordernumber} ||= undef;
1286
1287
    my $order = $schema->resultset('Aqorder')->create($new_order);
1288
    my $ordernumber = $order->id;
1289
1290
    unless ( $new_order->{parent_ordernumber} ) {
1291
        $order->update({ parent_ordernumber => $ordernumber });
1292
    }
1293
1294
    return $ordernumber;
1295
}
1296
1297
1298
1299
1300
#------------------------------------------------------------#
1301
1302
=head3 NewOrderItem
1303
1304
  &NewOrderItem();
1305
1306
=cut
1307
1308
sub NewOrderItem {
1309
    my ($itemnumber, $ordernumber)  = @_;
1310
    my $dbh = C4::Context->dbh;
1311
    my $query = qq|
1312
            INSERT INTO aqorders_items
1313
                (itemnumber, ordernumber)
1314
            VALUES (?,?)    |;
1315
1316
    my $sth = $dbh->prepare($query);
1317
    $sth->execute( $itemnumber, $ordernumber);
1318
}
1319
1320
#------------------------------------------------------------#
1232
#------------------------------------------------------------#
1321
1233
1322
=head3 ModOrder
1234
=head3 ModOrder
Lines 1535-1541 q{SELECT * FROM aqorders WHERE biblionumber=? AND aqorders.ordernumber=?}, Link Here
1535
        $order->{'rrp'} = $rrp;
1447
        $order->{'rrp'} = $rrp;
1536
        $order->{ecost} = $ecost;
1448
        $order->{ecost} = $ecost;
1537
        $order->{'orderstatus'} = 'complete';
1449
        $order->{'orderstatus'} = 'complete';
1538
        $new_ordernumber = NewOrder($order);
1450
        $new_ordernumber = Koha::Acquisition::Order->new($order)->insert->{ordernumber};
1539
1451
1540
        if ($received_items) {
1452
        if ($received_items) {
1541
            foreach my $itemnumber (@$received_items) {
1453
            foreach my $itemnumber (@$received_items) {
Lines 1932-1939 sub TransferOrder { Link Here
1932
    delete $order->{'ordernumber'};
1844
    delete $order->{'ordernumber'};
1933
    delete $order->{parent_ordernumber};
1845
    delete $order->{parent_ordernumber};
1934
    $order->{'basketno'} = $basketno;
1846
    $order->{'basketno'} = $basketno;
1935
    my $newordernumber;
1847
1936
    $newordernumber = NewOrder($order);
1848
    my $newordernumber = Koha::Acquisition::Order->new($order)->insert->{ordernumber};
1937
1849
1938
    $query = q{
1850
    $query = q{
1939
        UPDATE aqorders_items
1851
        UPDATE aqorders_items
(-)a/Koha/Acquisition/Order.pm (+92 lines)
Line 0 Link Here
1
package Koha::Acquisition::Order;
2
3
use Modern::Perl;
4
5
use Koha::Database;
6
use Koha::DateUtils qw( dt_from_string output_pref );
7
8
use Carp qw( croak );
9
10
use base qw( Class::Accessor );
11
12
# TODO fetch order from itemnumber (GetOrderFromItemnnumber)
13
# TODO Move code from GetOrder
14
sub fetch {
15
    my ( $class, $params ) = @_;
16
    my $ordernumber = $params->{ordernumber};
17
    return unless $ordernumber;
18
    my $schema = Koha::Database->new->schema;
19
20
    my $rs =
21
      $schema->resultset('Aqorder')->search( { ordernumber => $ordernumber },
22
        { result_class => 'DBIx::Class::ResultClass::HashRefInflator' } );
23
24
    return $class->new( $rs->first );
25
}
26
27
sub insert {
28
    my ($self) = @_;
29
30
    # if these parameters are missing, we can't continue
31
    for my $key (qw( basketno quantity biblionumber budget_id )) {
32
        croak "Cannot insert order: Mandatory parameter $key is missing"
33
          unless $self->{$key};
34
    }
35
36
    $self->{quantityreceived} ||= 0;
37
    $self->{entrydate} ||=
38
      output_pref( { dt => dt_from_string, dateformat => 'iso' } );
39
40
    my $schema  = Koha::Database->new->schema;
41
    my @columns = $schema->source('Aqorder')->columns;
42
43
    $self->{ordernumber} ||= undef;
44
45
    my $rs = $schema->resultset('Aqorder')->create(
46
        {
47
            map {
48
                exists $self->{$_} ? ( $_ => $self->{$_} ) : ()
49
            } @columns
50
        }
51
    );
52
    $self->{ordernumber} = $rs->id;
53
54
    unless ( $self->{parent_ordernumber} ) {
55
        $rs->update( { parent_ordernumber => $self->{ordernumber} } );
56
    }
57
58
    return $self;
59
}
60
61
sub add_item {
62
    my ( $self, $itemnumber )  = @_;
63
    my $schema = Koha::Database->new->schema;
64
    my $rs = $schema->resultset('AqordersItem');
65
    $rs->create({ ordernumber => $self->{ordernumber}, itemnumber => $itemnumber });
66
}
67
68
# TODO Move code from ModItemOrder
69
sub update_item {
70
    die "not implemented yet";
71
}
72
73
sub del_item {
74
    die "not implemented yet";
75
}
76
77
# TODO Move code from ModOrder
78
sub update {
79
    die "not implemented yet";
80
}
81
82
# TODO Move code from DelOrder
83
sub delete {
84
    die "not implemented yet";
85
}
86
87
# TODO Move code from TransferOrder
88
sub transfer {
89
    die "not implemented yet";
90
}
91
92
1;
(-)a/acqui/addorder.pl (-4 / +4 lines)
Lines 123-129 use strict; Link Here
123
use warnings;
123
use warnings;
124
use CGI;
124
use CGI;
125
use C4::Auth;			# get_template_and_user
125
use C4::Auth;			# get_template_and_user
126
use C4::Acquisition;	# NewOrder DelOrder ModOrder
126
use C4::Acquisition;    # DelOrder ModOrder
127
use C4::Suggestions;	# ModStatus
127
use C4::Suggestions;	# ModStatus
128
use C4::Biblio;			# AddBiblio TransformKohaToMarc
128
use C4::Biblio;			# AddBiblio TransformKohaToMarc
129
use C4::Budgets;
129
use C4::Budgets;
Lines 271-281 if ( $orderinfo->{quantity} ne '0' ) { Link Here
271
    $orderinfo->{unitprice} = $orderinfo->{ecost} if not defined $orderinfo->{unitprice} or $orderinfo->{unitprice} eq '';
271
    $orderinfo->{unitprice} = $orderinfo->{ecost} if not defined $orderinfo->{unitprice} or $orderinfo->{unitprice} eq '';
272
272
273
    # if we already have $ordernumber, then it's an ordermodif
273
    # if we already have $ordernumber, then it's an ordermodif
274
    my $order = Koha::Acquisition::Order->new($orderinfo);
274
    if ($$orderinfo{ordernumber}) {
275
    if ($$orderinfo{ordernumber}) {
275
        ModOrder( $orderinfo);
276
        ModOrder( $orderinfo);
276
    }
277
    }
277
    else { # else, it's a new line
278
    else { # else, it's a new line
278
        $orderinfo->{ordernumber} = NewOrder($orderinfo);
279
        $order->insert;
279
    }
280
    }
280
281
281
    # now, add items if applicable
282
    # now, add items if applicable
Lines 314-321 if ( $orderinfo->{quantity} ne '0' ) { Link Here
314
                                    'ITEM');
315
                                    'ITEM');
315
            my $record=MARC::Record::new_from_xml($xml, 'UTF-8');
316
            my $record=MARC::Record::new_from_xml($xml, 'UTF-8');
316
            my ($biblionumber,$bibitemnum,$itemnumber) = AddItemFromMarc($record,$$orderinfo{biblionumber});
317
            my ($biblionumber,$bibitemnum,$itemnumber) = AddItemFromMarc($record,$$orderinfo{biblionumber});
317
            NewOrderItem($itemnumber, $$orderinfo{ordernumber});
318
            $order->add_item($itemnumber);
318
319
        }
319
        }
320
    }
320
    }
321
321
(-)a/acqui/addorderiso2709.pl (-2 / +4 lines)
Lines 45-50 use C4::Suggestions; # GetSuggestion Link Here
45
use C4::Branch;         # GetBranches
45
use C4::Branch;         # GetBranches
46
use C4::Members;
46
use C4::Members;
47
47
48
use Koha::Acquisition::Order;
49
48
my $input = new CGI;
50
my $input = new CGI;
49
my ($template, $loggedinuser, $cookie, $userflags) = get_template_and_user({
51
my ($template, $loggedinuser, $cookie, $userflags) = get_template_and_user({
50
    template_name => "acqui/addorderiso2709.tt",
52
    template_name => "acqui/addorderiso2709.tt",
Lines 256-262 if ($op eq ""){ Link Here
256
258
257
        # remove uncertainprice flag if we have found a price in the MARC record
259
        # remove uncertainprice flag if we have found a price in the MARC record
258
        $orderinfo{uncertainprice} = 0 if $orderinfo{listprice};
260
        $orderinfo{uncertainprice} = 0 if $orderinfo{listprice};
259
        my $ordernumber = NewOrder( \%orderinfo );
261
        my $order = Koha::Acquisition::Order->new( \%orderinfo )->insert;
260
262
261
        # 4th, add items if applicable
263
        # 4th, add items if applicable
262
        # parse the item sent by the form, and create an item just for the import_record_id we are dealing with
264
        # parse the item sent by the form, and create an item just for the import_record_id we are dealing with
Lines 278-284 if ($op eq ""){ Link Here
278
            my $record = MARC::Record::new_from_xml( $xml, 'UTF-8' );
280
            my $record = MARC::Record::new_from_xml( $xml, 'UTF-8' );
279
            for (my $qtyloop=1;$qtyloop <= $c_quantity;$qtyloop++) {
281
            for (my $qtyloop=1;$qtyloop <= $c_quantity;$qtyloop++) {
280
                my ( $biblionumber, $bibitemnum, $itemnumber ) = AddItemFromMarc( $record, $biblionumber );
282
                my ( $biblionumber, $bibitemnum, $itemnumber ) = AddItemFromMarc( $record, $biblionumber );
281
                NewOrderItem( $itemnumber, $ordernumber );
283
                $order->add_item( $itemnumber );
282
            }
284
            }
283
        } else {
285
        } else {
284
            SetImportRecordStatus( $biblio->{'import_record_id'}, 'imported' );
286
            SetImportRecordStatus( $biblio->{'import_record_id'}, 'imported' );
(-)a/acqui/finishreceive.pl (-1 / +2 lines)
Lines 141-146 if ($quantityrec > $origquantityrec ) { Link Here
141
            push @{$itemhash{$itemid[$i]}->{'ind_tag'}},$ind_tag[$i];
141
            push @{$itemhash{$itemid[$i]}->{'ind_tag'}},$ind_tag[$i];
142
            push @{$itemhash{$itemid[$i]}->{'indicator'}},$indicator[$i];
142
            push @{$itemhash{$itemid[$i]}->{'indicator'}},$indicator[$i];
143
        }
143
        }
144
        my $order = Koha::Acquisition::Order->fetch({ ordernumber => $new_ordernumber });
144
        foreach my $item (keys %itemhash){
145
        foreach my $item (keys %itemhash){
145
            my $xml = TransformHtmlToXml( $itemhash{$item}->{'tags'},
146
            my $xml = TransformHtmlToXml( $itemhash{$item}->{'tags'},
146
                                          $itemhash{$item}->{'subfields'},
147
                                          $itemhash{$item}->{'subfields'},
Lines 149-155 if ($quantityrec > $origquantityrec ) { Link Here
149
                                          $itemhash{$item}->{'indicator'},'ITEM');
150
                                          $itemhash{$item}->{'indicator'},'ITEM');
150
            my $record=MARC::Record::new_from_xml($xml, 'UTF-8');
151
            my $record=MARC::Record::new_from_xml($xml, 'UTF-8');
151
            my (undef,$bibitemnum,$itemnumber) = AddItemFromMarc($record,$biblionumber);
152
            my (undef,$bibitemnum,$itemnumber) = AddItemFromMarc($record,$biblionumber);
152
            NewOrderItem($itemnumber, $new_ordernumber);
153
            $order->add_item( $itemnumber );
153
        }
154
        }
154
    }
155
    }
155
}
156
}
(-)a/t/db_dependent/Acquisition.t (-3 / +4 lines)
Lines 8-14 use POSIX qw(strftime); Link Here
8
8
9
use C4::Bookseller qw( GetBookSellerFromId );
9
use C4::Bookseller qw( GetBookSellerFromId );
10
10
11
use Test::More tests => 74;
11
use Test::More tests => 75;
12
12
13
BEGIN {
13
BEGIN {
14
    use_ok('C4::Acquisition');
14
    use_ok('C4::Acquisition');
Lines 16-21 BEGIN { Link Here
16
    use_ok('C4::Biblio');
16
    use_ok('C4::Biblio');
17
    use_ok('C4::Budgets');
17
    use_ok('C4::Budgets');
18
    use_ok('C4::Bookseller');
18
    use_ok('C4::Bookseller');
19
    use_ok('Koha::Acquisition::Order');
19
}
20
}
20
21
21
# Sub used for testing C4::Acquisition subs returning order(s):
22
# Sub used for testing C4::Acquisition subs returning order(s):
Lines 25-31 BEGIN { Link Here
25
# params :
26
# params :
26
# $exp_fields             : arrayref whose elements are the keys we expect to find
27
# $exp_fields             : arrayref whose elements are the keys we expect to find
27
# $original_order_content : hashref whose 2 keys str and num contains hashrefs
28
# $original_order_content : hashref whose 2 keys str and num contains hashrefs
28
#                           containing content fields of the order created with NewOrder
29
#                           containing content fields of the order created with Koha::Acquisition::Order
29
# $order_to_check         : hashref whose keys/values are the content of an order
30
# $order_to_check         : hashref whose keys/values are the content of an order
30
#                           returned by the C4::Acquisition sub we are testing
31
#                           returned by the C4::Acquisition sub we are testing
31
# returns :
32
# returns :
Lines 244-250 for ( 0 .. 4 ) { Link Here
244
      values %{ $order_content[$_]->{num} };
245
      values %{ $order_content[$_]->{num} };
245
    @ocontent{ keys %{ $order_content[$_]->{str} } } =
246
    @ocontent{ keys %{ $order_content[$_]->{str} } } =
246
      values %{ $order_content[$_]->{str} };
247
      values %{ $order_content[$_]->{str} };
247
    $ordernumbers[$_] = C4::Acquisition::NewOrder( \%ocontent );
248
    $ordernumbers[$_] = Koha::Acquisition::Order->new( \%ocontent )->insert->{ordernumber};
248
    $order_content[$_]->{str}->{ordernumber} = $ordernumbers[$_];
249
    $order_content[$_]->{str}->{ordernumber} = $ordernumbers[$_];
249
}
250
}
250
251
(-)a/t/db_dependent/Acquisition/CancelReceipt.t (-8 / +11 lines)
Lines 12-17 use C4::Budgets; Link Here
12
use t::lib::Mocks;
12
use t::lib::Mocks;
13
13
14
use Koha::DateUtils;
14
use Koha::DateUtils;
15
use Koha::Acquisition::Order;
15
use MARC::Record;
16
use MARC::Record;
16
17
17
my $dbh = C4::Context->dbh;
18
my $dbh = C4::Context->dbh;
Lines 44-57 my ($biblionumber, $biblioitemnumber) = AddBiblio(MARC::Record->new, ''); Link Here
44
my $itemnumber = AddItem({}, $biblionumber);
45
my $itemnumber = AddItem({}, $biblionumber);
45
46
46
t::lib::Mocks::mock_preference('AcqCreateItem', 'receiving');
47
t::lib::Mocks::mock_preference('AcqCreateItem', 'receiving');
47
my $ordernumber = C4::Acquisition::NewOrder(
48
my $order = Koha::Acquisition::Order->new(
48
    {
49
    {
49
        basketno => $basketno1,
50
        basketno => $basketno1,
50
        quantity => 2,
51
        quantity => 2,
51
        biblionumber => $biblionumber,
52
        biblionumber => $biblionumber,
52
        budget_id => $budget->{budget_id},
53
        budget_id => $budget->{budget_id},
53
    }
54
    }
54
);
55
)->insert;
56
my $ordernumber = $order->{ordernumber};
55
57
56
ModReceiveOrder(
58
ModReceiveOrder(
57
    {
59
    {
Lines 62-89 ModReceiveOrder( Link Here
62
    }
64
    }
63
);
65
);
64
66
65
NewOrderItem($itemnumber, $ordernumber);
67
$order->add_item( $itemnumber );
66
68
67
CancelReceipt($ordernumber);
69
CancelReceipt($ordernumber);
68
70
69
my $order = GetOrder( $ordernumber );
71
$order = GetOrder( $ordernumber );
70
is(scalar GetItemnumbersFromOrder($order->{ordernumber}), 0, "Create items on receiving: 0 item exist after cancelling a receipt");
72
is(scalar GetItemnumbersFromOrder($order->{ordernumber}), 0, "Create items on receiving: 0 item exist after cancelling a receipt");
71
73
72
my $itemnumber1 = AddItem({}, $biblionumber);
74
my $itemnumber1 = AddItem({}, $biblionumber);
73
my $itemnumber2 = AddItem({}, $biblionumber);
75
my $itemnumber2 = AddItem({}, $biblionumber);
74
t::lib::Mocks::mock_preference('AcqCreateItem', 'ordering');
76
t::lib::Mocks::mock_preference('AcqCreateItem', 'ordering');
75
t::lib::Mocks::mock_preference('AcqItemSetSubfieldsWhenReceiptIsCancelled', '7=9'); # notforloan is mapped with 952$7
77
t::lib::Mocks::mock_preference('AcqItemSetSubfieldsWhenReceiptIsCancelled', '7=9'); # notforloan is mapped with 952$7
76
$ordernumber = C4::Acquisition::NewOrder(
78
$order = Koha::Acquisition::Order->new(
77
    {
79
    {
78
        basketno => $basketno1,
80
        basketno => $basketno1,
79
        quantity => 2,
81
        quantity => 2,
80
        biblionumber => $biblionumber,
82
        biblionumber => $biblionumber,
81
        budget_id => $budget->{budget_id},
83
        budget_id => $budget->{budget_id},
82
    }
84
    }
83
);
85
)->insert;
86
$ordernumber = $order->{ordernumber};
84
87
85
NewOrderItem($itemnumber1, $ordernumber);
88
$order->add_item( $itemnumber1 );
86
NewOrderItem($itemnumber2, $ordernumber);
89
$order->add_item( $itemnumber2 );
87
90
88
my ( undef, $new_ordernumber ) = ModReceiveOrder(
91
my ( undef, $new_ordernumber ) = ModReceiveOrder(
89
    {
92
    {
(-)a/t/db_dependent/Acquisition/GetBasketsInfosByBookseller.t (-6 / +10 lines)
Lines 4-14 use Modern::Perl; Link Here
4
use Test::More tests => 18;
4
use Test::More tests => 18;
5
use Data::Dumper;
5
use Data::Dumper;
6
6
7
use C4::Acquisition qw( NewOrder NewBasket GetBasketsInfosByBookseller );
7
use C4::Acquisition qw( NewBasket GetBasketsInfosByBookseller );
8
use C4::Biblio qw( AddBiblio );
8
use C4::Biblio qw( AddBiblio );
9
use C4::Bookseller qw( AddBookseller );
9
use C4::Bookseller qw( AddBookseller );
10
use C4::Budgets qw( AddBudget );
10
use C4::Budgets qw( AddBudget );
11
use C4::Context;
11
use C4::Context;
12
13
use Koha::Acquisition::Order;
14
12
my $dbh = C4::Context->dbh;
15
my $dbh = C4::Context->dbh;
13
$dbh->{AutoCommit} = 0;
16
$dbh->{AutoCommit} = 0;
14
$dbh->{RaiseError} = 1;
17
$dbh->{RaiseError} = 1;
Lines 34-61 my $budgetid = C4::Budgets::AddBudget( Link Here
34
);
37
);
35
my $budget = C4::Budgets::GetBudget( $budgetid );
38
my $budget = C4::Budgets::GetBudget( $budgetid );
36
39
37
my ($ordernumber1, $ordernumber2, $ordernumber3);
38
my ($biblionumber1, $biblioitemnumber1) = AddBiblio(MARC::Record->new, '');
40
my ($biblionumber1, $biblioitemnumber1) = AddBiblio(MARC::Record->new, '');
39
my ($biblionumber2, $biblioitemnumber2) = AddBiblio(MARC::Record->new, '');
41
my ($biblionumber2, $biblioitemnumber2) = AddBiblio(MARC::Record->new, '');
40
my ($biblionumber3, $biblioitemnumber3) = AddBiblio(MARC::Record->new, '');
42
my ($biblionumber3, $biblioitemnumber3) = AddBiblio(MARC::Record->new, '');
41
43
42
$ordernumber1 = C4::Acquisition::NewOrder(
44
my $order1 = Koha::Acquisition::Order->new(
43
    {
45
    {
44
        basketno => $basketno,
46
        basketno => $basketno,
45
        quantity => 2,
47
        quantity => 2,
46
        biblionumber => $biblionumber1,
48
        biblionumber => $biblionumber1,
47
        budget_id => $budget->{budget_id},
49
        budget_id => $budget->{budget_id},
48
    }
50
    }
49
);
51
)->insert;
52
my $ordernumber1 = $order1->{ordernumber};
50
53
51
$ordernumber2 = C4::Acquisition::NewOrder(
54
my $order2 = Koha::Acquisition::Order->new(
52
    {
55
    {
53
        basketno => $basketno,
56
        basketno => $basketno,
54
        quantity => 4,
57
        quantity => 4,
55
        biblionumber => $biblionumber2,
58
        biblionumber => $biblionumber2,
56
        budget_id => $budget->{budget_id},
59
        budget_id => $budget->{budget_id},
57
    }
60
    }
58
);
61
)->insert;
62
my $ordernumber2 = $order2->{ordernumber};
59
63
60
my $baskets = C4::Acquisition::GetBasketsInfosByBookseller( $supplierid );
64
my $baskets = C4::Acquisition::GetBasketsInfosByBookseller( $supplierid );
61
is( scalar(@$baskets), 1, 'Start: 1 basket' );
65
is( scalar(@$baskets), 1, 'Start: 1 basket' );
(-)a/t/db_dependent/Acquisition/GetOrdersByBiblionumber.t (-7 / +12 lines)
Lines 7-12 use C4::Acquisition; Link Here
7
use C4::Biblio;
7
use C4::Biblio;
8
use C4::Bookseller;
8
use C4::Bookseller;
9
use C4::Budgets;
9
use C4::Budgets;
10
11
use Koha::Acquisition::Order;
12
10
use MARC::Record;
13
use MARC::Record;
11
14
12
#Start transaction
15
#Start transaction
Lines 36-70 my $budgetid = C4::Budgets::AddBudget( Link Here
36
39
37
my $budget = C4::Budgets::GetBudget( $budgetid );
40
my $budget = C4::Budgets::GetBudget( $budgetid );
38
41
39
my ($ordernumber1, $ordernumber2, $ordernumber3);
40
my ($biblionumber1, $biblioitemnumber1) = AddBiblio(MARC::Record->new, '');
42
my ($biblionumber1, $biblioitemnumber1) = AddBiblio(MARC::Record->new, '');
41
my ($biblionumber2, $biblioitemnumber2) = AddBiblio(MARC::Record->new, '');
43
my ($biblionumber2, $biblioitemnumber2) = AddBiblio(MARC::Record->new, '');
42
$ordernumber1 = C4::Acquisition::NewOrder(
44
my $order1 = Koha::Acquisition::Order->new(
43
    {
45
    {
44
        basketno => $basketno,
46
        basketno => $basketno,
45
        quantity => 24,
47
        quantity => 24,
46
        biblionumber => $biblionumber1,
48
        biblionumber => $biblionumber1,
47
        budget_id => $budget->{budget_id},
49
        budget_id => $budget->{budget_id},
48
    }
50
    }
49
);
51
)->insert;
52
my $ordernumber1 = $order1->{ordernumber};
50
53
51
$ordernumber2 = C4::Acquisition::NewOrder(
54
my $order2 = Koha::Acquisition::Order->new(
52
    {
55
    {
53
        basketno => $basketno,
56
        basketno => $basketno,
54
        quantity => 42,
57
        quantity => 42,
55
        biblionumber => $biblionumber2,
58
        biblionumber => $biblionumber2,
56
        budget_id => $budget->{budget_id},
59
        budget_id => $budget->{budget_id},
57
    }
60
    }
58
);
61
)->insert;
62
my $ordernumber2 = $order1->{ordernumber};
59
63
60
$ordernumber3 = C4::Acquisition::NewOrder(
64
my $order3 = Koha::Acquisition::Order->new(
61
    {
65
    {
62
        basketno => $basketno,
66
        basketno => $basketno,
63
        quantity => 4,
67
        quantity => 4,
64
        biblionumber => $biblionumber2,
68
        biblionumber => $biblionumber2,
65
        budget_id => $budget->{budget_id},
69
        budget_id => $budget->{budget_id},
66
    }
70
    }
67
);
71
)->insert;
72
my $ordernumber3 = $order1->{ordernumber};
68
73
69
my @orders = GetOrdersByBiblionumber();
74
my @orders = GetOrdersByBiblionumber();
70
is(scalar(@orders), 0, 'GetOrdersByBiblionumber : no argument, return undef');
75
is(scalar(@orders), 0, 'GetOrdersByBiblionumber : no argument, return undef');
(-)a/t/db_dependent/Acquisition/Invoices.t (-7 / +12 lines)
Lines 9-14 use warnings; Link Here
9
use C4::Bookseller qw( GetBookSellerFromId );
9
use C4::Bookseller qw( GetBookSellerFromId );
10
use C4::Biblio qw( AddBiblio );
10
use C4::Biblio qw( AddBiblio );
11
11
12
use Koha::Acquisition::Order;
13
12
use Test::More tests => 22;
14
use Test::More tests => 22;
13
15
14
BEGIN {
16
BEGIN {
Lines 42-48 my $budgetid = C4::Budgets::AddBudget( Link Here
42
);
44
);
43
my $budget = C4::Budgets::GetBudget( $budgetid );
45
my $budget = C4::Budgets::GetBudget( $budgetid );
44
46
45
my ($ordernumber1, $ordernumber2, $ordernumber3);
46
my $bibrec1 = MARC::Record->new();
47
my $bibrec1 = MARC::Record->new();
47
$bibrec1->append_fields(
48
$bibrec1->append_fields(
48
    MARC::Field->new('020', '', '', 'a' => '1234567890'),
49
    MARC::Field->new('020', '', '', 'a' => '1234567890'),
Lines 53-77 $bibrec1->append_fields( Link Here
53
my ($biblionumber1, $biblioitemnumber1) = AddBiblio($bibrec1, '');
54
my ($biblionumber1, $biblioitemnumber1) = AddBiblio($bibrec1, '');
54
my ($biblionumber2, $biblioitemnumber2) = AddBiblio(MARC::Record->new, '');
55
my ($biblionumber2, $biblioitemnumber2) = AddBiblio(MARC::Record->new, '');
55
my ($biblionumber3, $biblioitemnumber3) = AddBiblio(MARC::Record->new, '');
56
my ($biblionumber3, $biblioitemnumber3) = AddBiblio(MARC::Record->new, '');
56
$ordernumber1 = C4::Acquisition::NewOrder(
57
58
my $order1 = Koha::Acquisition::Order->new(
57
    {
59
    {
58
        basketno => $basketno,
60
        basketno => $basketno,
59
        quantity => 2,
61
        quantity => 2,
60
        biblionumber => $biblionumber1,
62
        biblionumber => $biblionumber1,
61
        budget_id => $budget->{budget_id},
63
        budget_id => $budget->{budget_id},
62
    }
64
    }
63
);
65
)->insert;
66
my $ordernumber1 = $order1->{ordernumber};
64
67
65
$ordernumber2 = C4::Acquisition::NewOrder(
68
my $order2 = Koha::Acquisition::Order->new(
66
    {
69
    {
67
        basketno => $basketno,
70
        basketno => $basketno,
68
        quantity => 1,
71
        quantity => 1,
69
        biblionumber => $biblionumber2,
72
        biblionumber => $biblionumber2,
70
        budget_id => $budget->{budget_id},
73
        budget_id => $budget->{budget_id},
71
    }
74
    }
72
);
75
)->insert;
76
my $ordernumber2 = $order2->{ordernumber};
73
77
74
$ordernumber3 = C4::Acquisition::NewOrder(
78
my $order3 = Koha::Acquisition::Order->new(
75
    {
79
    {
76
        basketno => $basketno,
80
        basketno => $basketno,
77
        quantity => 1,
81
        quantity => 1,
Lines 80-86 $ordernumber3 = C4::Acquisition::NewOrder( Link Here
80
        ecost => 42,
84
        ecost => 42,
81
        rrp => 42,
85
        rrp => 42,
82
    }
86
    }
83
);
87
)->insert;
88
my $ordernumber3 = $order3->{ordernumber};
84
89
85
my $invoiceid1 = AddInvoice(invoicenumber => 'invoice1', booksellerid => $booksellerid, unknown => "unknown");
90
my $invoiceid1 = AddInvoice(invoicenumber => 'invoice1', booksellerid => $booksellerid, unknown => "unknown");
86
my $invoiceid2 = AddInvoice(invoicenumber => 'invoice2', booksellerid => $booksellerid, unknown => "unknown",
91
my $invoiceid2 = AddInvoice(invoicenumber => 'invoice2', booksellerid => $booksellerid, unknown => "unknown",
(-)a/t/db_dependent/Acquisition/NewOrder.t (-14 / +14 lines)
Lines 9-14 use C4::Bookseller; Link Here
9
use C4::Budgets;
9
use C4::Budgets;
10
use MARC::Record;
10
use MARC::Record;
11
use Koha::DateUtils qw( dt_from_string output_pref );
11
use Koha::DateUtils qw( dt_from_string output_pref );
12
use Koha::Acquisition::Order;
12
13
13
my $dbh = C4::Context->dbh;
14
my $dbh = C4::Context->dbh;
14
$dbh->{AutoCommit} = 0;
15
$dbh->{AutoCommit} = 0;
Lines 41-52 my ($biblionumber2, $biblioitemnumber2) = AddBiblio(MARC::Record->new, ''); Link Here
41
42
42
43
43
# returns undef and croaks if basketno, quantity, biblionumber or budget_id is missing
44
# returns undef and croaks if basketno, quantity, biblionumber or budget_id is missing
44
my $ordernumber = eval { C4::Acquisition::NewOrder() };
45
my $order = eval { Koha::Acquisition::Order->new->insert };
45
my $return_error = $@;
46
my $return_error = $@;
46
ok(
47
ok(
47
    ( ! defined $ordernumber )
48
    ( ! defined $order )
48
      && ( defined $return_error ),
49
      && ( defined $return_error ),
49
    "NewOrder with no params returns undef and croaks"
50
    "Inserting an order with no params returns undef and croaks"
50
);
51
);
51
52
52
my $mandatoryparams = {
53
my $mandatoryparams = {
Lines 59-86 my @mandatoryparams_keys = keys %$mandatoryparams; Link Here
59
foreach my $mandatoryparams_key (@mandatoryparams_keys) {
60
foreach my $mandatoryparams_key (@mandatoryparams_keys) {
60
    my %test_missing_mandatoryparams = %$mandatoryparams;
61
    my %test_missing_mandatoryparams = %$mandatoryparams;
61
    delete $test_missing_mandatoryparams{$mandatoryparams_key};
62
    delete $test_missing_mandatoryparams{$mandatoryparams_key};
62
    eval {
63
    $order = eval {
63
        $ordernumber =
64
          Koha::Acquisition::Order->new( \%test_missing_mandatoryparams )->insert;
64
          C4::Acquisition::NewOrder( \%test_missing_mandatoryparams );
65
    };
65
    };
66
    $return_error = $@;
66
    $return_error = $@;
67
    my $expected_error = "Cannot insert order: Mandatory parameter $mandatoryparams_key is missing";
67
    my $expected_error = "Cannot insert order: Mandatory parameter $mandatoryparams_key is missing";
68
    ok(
68
    ok(
69
        ( !( defined $ordernumber ) )
69
        ( !( defined $order ) )
70
          && ( index( $return_error, $expected_error ) >= 0 ),
70
          && ( index( $return_error, $expected_error ) >= 0 ),
71
"NewOrder with no $mandatoryparams_key returns undef and croaks with expected error message"
71
"Inserting an order with no $mandatoryparams_key returns undef and croaks with expected error message"
72
    );
72
    );
73
}
73
}
74
74
75
$ordernumber = C4::Acquisition::NewOrder(
75
$order = Koha::Acquisition::Order->new(
76
    {
76
    {
77
        basketno => $basketno,
77
        basketno => $basketno,
78
        quantity => 24,
78
        quantity => 24,
79
        biblionumber => $biblionumber1,
79
        biblionumber => $biblionumber1,
80
        budget_id => $budget->{budget_id},
80
        budget_id => $budget->{budget_id},
81
    }
81
    }
82
);
82
)->insert;
83
83
my $ordernumber = $order->{ordernumber};
84
my $order = C4::Acquisition::GetOrder( $ordernumber );
84
$order = Koha::Acquisition::Order->fetch({ ordernumber => $ordernumber });
85
is( $order->{quantityreceived}, 0, 'NewOrder set quantityreceivedto 0 if undef is given' );
85
is( $order->{quantityreceived}, 0, 'Koha::Acquisition::Order->insert set quantityreceivedto 0 if undef is given' );
86
is( $order->{entrydate}, output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 }), 'NewOrder set entrydate to today' );
86
is( $order->{entrydate}, output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 }), 'Koha::Acquisition::Order->insert set entrydate to today' );
(-)a/t/db_dependent/Acquisition/OrderFromSubscription.t (-4 / +7 lines)
Lines 8-13 use_ok('C4::Biblio'); Link Here
8
use_ok('C4::Budgets');
8
use_ok('C4::Budgets');
9
use_ok('C4::Serials');
9
use_ok('C4::Serials');
10
10
11
use Koha::Acquisition::Order;
12
11
# Start transaction
13
# Start transaction
12
my $dbh = C4::Context->dbh;
14
my $dbh = C4::Context->dbh;
13
$dbh->{AutoCommit} = 0;
15
$dbh->{AutoCommit} = 0;
Lines 56-63 ok($basketno = NewBasket($booksellerid, 1), "NewBasket( $booksellerid , 1 ) re Link Here
56
58
57
my $cost = 42.00;
59
my $cost = 42.00;
58
my $subscription = GetSubscription( $subscriptionid );
60
my $subscription = GetSubscription( $subscriptionid );
59
my $ordernumber;
61
60
$ordernumber = NewOrder({
62
my $order = Koha::Acquisition::Order->new({
61
    biblionumber => $subscription->{biblionumber},
63
    biblionumber => $subscription->{biblionumber},
62
    entrydate => '01-01-2013',
64
    entrydate => '01-01-2013',
63
    quantity => 1,
65
    quantity => 1,
Lines 71-82 $ordernumber = NewOrder({ Link Here
71
    orderstatus => 'new',
73
    orderstatus => 'new',
72
    subscriptionid => $subscription->{subscriptionid},
74
    subscriptionid => $subscription->{subscriptionid},
73
    budget_id => $budget_id,
75
    budget_id => $budget_id,
74
});
76
})->insert;
77
my $ordernumber = $order->{ordernumber};
75
78
76
my $is_currently_on_order = subscriptionCurrentlyOnOrder( $subscription->{subscriptionid} );
79
my $is_currently_on_order = subscriptionCurrentlyOnOrder( $subscription->{subscriptionid} );
77
is ( $is_currently_on_order, 1, "The subscription is currently on order");
80
is ( $is_currently_on_order, 1, "The subscription is currently on order");
78
81
79
my $order = GetLastOrderNotReceivedFromSubscriptionid( $subscription->{subscriptionid} );
82
$order = GetLastOrderNotReceivedFromSubscriptionid( $subscription->{subscriptionid} );
80
is ( $order->{subscriptionid}, $subscription->{subscriptionid}, "test subscriptionid for the last order not received");
83
is ( $order->{subscriptionid}, $subscription->{subscriptionid}, "test subscriptionid for the last order not received");
81
ok( $order->{ecost} == $cost, "test cost for the last order not received");
84
ok( $order->{ecost} == $cost, "test cost for the last order not received");
82
85
(-)a/t/db_dependent/Acquisition/TransferOrder.t (-4 / +5 lines)
Lines 10-15 use C4::Items; Link Here
10
use C4::Bookseller;
10
use C4::Bookseller;
11
use C4::Budgets;
11
use C4::Budgets;
12
use Koha::DateUtils;
12
use Koha::DateUtils;
13
use Koha::Acquisition::Order;
13
use MARC::Record;
14
use MARC::Record;
14
15
15
my $dbh = C4::Context->dbh;
16
my $dbh = C4::Context->dbh;
Lines 54-71 my $budget = C4::Budgets::GetBudget( $budgetid ); Link Here
54
my ($biblionumber, $biblioitemnumber) = AddBiblio(MARC::Record->new, '');
55
my ($biblionumber, $biblioitemnumber) = AddBiblio(MARC::Record->new, '');
55
my $itemnumber = AddItem({}, $biblionumber);
56
my $itemnumber = AddItem({}, $biblionumber);
56
57
57
my $ordernumber = C4::Acquisition::NewOrder(
58
my $order = Koha::Acquisition::Order->new(
58
    {
59
    {
59
        basketno => $basketno1,
60
        basketno => $basketno1,
60
        quantity => 2,
61
        quantity => 2,
61
        biblionumber => $biblionumber,
62
        biblionumber => $biblionumber,
62
        budget_id => $budget->{budget_id},
63
        budget_id => $budget->{budget_id},
63
    }
64
    }
64
);
65
)->insert;
65
NewOrderItem($itemnumber, $ordernumber);
66
my $ordernumber = $order->{ordernumber};
67
$order->add_item( $itemnumber );
66
68
67
# Begin tests
69
# Begin tests
68
my $order;
69
is(scalar GetOrders($basketno1), 1, "1 order in basket1");
70
is(scalar GetOrders($basketno1), 1, "1 order in basket1");
70
($order) = GetOrders($basketno1);
71
($order) = GetOrders($basketno1);
71
is(scalar GetItemnumbersFromOrder($order->{ordernumber}), 1, "1 item in basket1's order");
72
is(scalar GetItemnumbersFromOrder($order->{ordernumber}), 1, "1 item in basket1's order");
(-)a/t/db_dependent/Acquisition/close_reopen_basket.t (-5 / +8 lines)
Lines 9-14 use C4::Bookseller; Link Here
9
use C4::Budgets;
9
use C4::Budgets;
10
use C4::Context;
10
use C4::Context;
11
11
12
use Koha::Acquisition::Order;
13
12
# Start transaction
14
# Start transaction
13
my $dbh = C4::Context->dbh;
15
my $dbh = C4::Context->dbh;
14
$dbh->{AutoCommit} = 0;
16
$dbh->{AutoCommit} = 0;
Lines 43-66 my $budget = C4::Budgets::GetBudget( $budgetid ); Link Here
43
my ($biblionumber1, $biblioitemnumber1) = AddBiblio(MARC::Record->new, '');
45
my ($biblionumber1, $biblioitemnumber1) = AddBiblio(MARC::Record->new, '');
44
my ($biblionumber2, $biblioitemnumber2) = AddBiblio(MARC::Record->new, '');
46
my ($biblionumber2, $biblioitemnumber2) = AddBiblio(MARC::Record->new, '');
45
47
46
my ($ordernumber1, $ordernumber2);
48
my $order1 = Koha::Acquisition::Order->new(
47
$ordernumber1 = C4::Acquisition::NewOrder(
48
    {
49
    {
49
        basketno => $basketno,
50
        basketno => $basketno,
50
        quantity => 24,
51
        quantity => 24,
51
        biblionumber => $biblionumber1,
52
        biblionumber => $biblionumber1,
52
        budget_id => $budget->{budget_id},
53
        budget_id => $budget->{budget_id},
53
    }
54
    }
54
);
55
)->insert;
56
my $ordernumber1 = $order1->{ordernumber};
55
57
56
$ordernumber2 = C4::Acquisition::NewOrder(
58
my $order2 = Koha::Acquisition::Order->new(
57
    {
59
    {
58
        basketno => $basketno,
60
        basketno => $basketno,
59
        quantity => 42,
61
        quantity => 42,
60
        biblionumber => $biblionumber2,
62
        biblionumber => $biblionumber2,
61
        budget_id => $budget->{budget_id},
63
        budget_id => $budget->{budget_id},
62
    }
64
    }
63
);
65
)->insert;
66
my $ordernumber2 = $order2->{ordernumber};
64
67
65
my $nb_biblio = C4::Acquisition::GetBiblioCountByBasketno( $basketno );
68
my $nb_biblio = C4::Acquisition::GetBiblioCountByBasketno( $basketno );
66
is ( $nb_biblio, 2, "There are 2 biblio for this basket" );
69
is ( $nb_biblio, 2, "There are 2 biblio for this basket" );
(-)a/t/db_dependent/Bookseller.t (-9 / +17 lines)
Lines 14-19 use C4::Serials; Link Here
14
use C4::Budgets;
14
use C4::Budgets;
15
use C4::Biblio;
15
use C4::Biblio;
16
16
17
use Koha::Acquisition::Order;
18
17
BEGIN {
19
BEGIN {
18
    use_ok('C4::Bookseller');
20
    use_ok('C4::Bookseller');
19
}
21
}
Lines 350-357 is(scalar(@subscriptions), 1, 'search for subscriptions by call number'); Link Here
350
is(scalar(@subscriptions), 1, 'search for subscriptions by location');
352
is(scalar(@subscriptions), 1, 'search for subscriptions by location');
351
353
352
#Add 4 orders
354
#Add 4 orders
353
my ( $ordernumber1, $ordernumber2, $ordernumber3, $ordernumber4 );
355
my $order1 = Koha::Acquisition::Order->new(
354
$ordernumber1 = C4::Acquisition::NewOrder(
355
    {
356
    {
356
        basketno         => $basketno1,
357
        basketno         => $basketno1,
357
        quantity         => 24,
358
        quantity         => 24,
Lines 368-375 $ordernumber1 = C4::Acquisition::NewOrder( Link Here
368
        ecost            => 10,
369
        ecost            => 10,
369
        datereceived     => '01-06-2013'
370
        datereceived     => '01-06-2013'
370
    }
371
    }
371
);
372
)->insert;
372
$ordernumber2 = C4::Acquisition::NewOrder(
373
my $ordernumber1 = $order1->{ordernumber};
374
375
my $order2 = Koha::Acquisition::Order->new(
373
    {
376
    {
374
        basketno       => $basketno2,
377
        basketno       => $basketno2,
375
        quantity       => 20,
378
        quantity       => 20,
Lines 384-391 $ordernumber2 = C4::Acquisition::NewOrder( Link Here
384
        rrp            => 10,
387
        rrp            => 10,
385
        ecost          => 10,
388
        ecost          => 10,
386
    }
389
    }
387
);
390
)->insert;
388
$ordernumber3 = C4::Acquisition::NewOrder(
391
my $ordernumber2 = $order2->{ordernumber};
392
393
my $order3 = Koha::Acquisition::Order->new(
389
    {
394
    {
390
        basketno       => $basketno3,
395
        basketno       => $basketno3,
391
        quantity       => 20,
396
        quantity       => 20,
Lines 400-407 $ordernumber3 = C4::Acquisition::NewOrder( Link Here
400
        rrp            => 11,
405
        rrp            => 11,
401
        ecost          => 11,
406
        ecost          => 11,
402
    }
407
    }
403
);
408
)->insert;
404
$ordernumber4 = C4::Acquisition::NewOrder(
409
my $ordernumber3 = $order3->{ordernumber};
410
411
my $order4 = Koha::Acquisition::Order->new(
405
    {
412
    {
406
        basketno         => $basketno4,
413
        basketno         => $basketno4,
407
        quantity         => 20,
414
        quantity         => 20,
Lines 417-423 $ordernumber4 = C4::Acquisition::NewOrder( Link Here
417
        ecost            => 11,
424
        ecost            => 11,
418
        quantityreceived => 20
425
        quantityreceived => 20
419
    }
426
    }
420
);
427
)->insert;
428
my $ordernumber4 = $order4->{ordernumber};
421
429
422
#Test cases:
430
#Test cases:
423
# Sample datas :
431
# Sample datas :
(-)a/t/db_dependent/Budgets.t (-4 / +8 lines)
Lines 10-15 use C4::Bookseller; Link Here
10
use C4::Acquisition;
10
use C4::Acquisition;
11
use C4::Dates;
11
use C4::Dates;
12
12
13
use Koha::Acquisition::Order;
14
13
use YAML;
15
use YAML;
14
my $dbh = C4::Context->dbh;
16
my $dbh = C4::Context->dbh;
15
$dbh->{AutoCommit} = 0;
17
$dbh->{AutoCommit} = 0;
Lines 304-310 my $item_quantity = 2; Link Here
304
my $number_of_orders_to_move = 0;
306
my $number_of_orders_to_move = 0;
305
for my $infos (@order_infos) {
307
for my $infos (@order_infos) {
306
    for ( 1 .. $infos->{pending_quantity} ) {
308
    for ( 1 .. $infos->{pending_quantity} ) {
307
        my $ordernumber = C4::Acquisition::NewOrder(
309
        my $order = Koha::Acquisition::Order->new(
308
            {
310
            {
309
                basketno           => $basketno,
311
                basketno           => $basketno,
310
                biblionumber       => $biblionumber,
312
                biblionumber       => $biblionumber,
Lines 321-332 for my $infos (@order_infos) { Link Here
321
                uncertainprice     => 0,
323
                uncertainprice     => 0,
322
                gstrate            => 0,
324
                gstrate            => 0,
323
            }
325
            }
324
        );
326
        )->insert;
327
        my $ordernumber = $order->{ordernumber};
325
        push @{ $budgets{$infos->{budget_id}} }, $ordernumber;
328
        push @{ $budgets{$infos->{budget_id}} }, $ordernumber;
326
        $number_of_orders_to_move++;
329
        $number_of_orders_to_move++;
327
    }
330
    }
328
    for ( 1 .. $infos->{spent_quantity} ) {
331
    for ( 1 .. $infos->{spent_quantity} ) {
329
        my $ordernumber = C4::Acquisition::NewOrder(
332
        my $order = Koha::Acquisition::Order->new(
330
            {
333
            {
331
                basketno           => $basketno,
334
                basketno           => $basketno,
332
                biblionumber       => $biblionumber,
335
                biblionumber       => $biblionumber,
Lines 343-349 for my $infos (@order_infos) { Link Here
343
                uncertainprice     => 0,
346
                uncertainprice     => 0,
344
                gstrate            => 0,
347
                gstrate            => 0,
345
            }
348
            }
346
        );
349
        )->insert;
350
        my $ordernumber = $order->{ordernumber};
347
        ModReceiveOrder({
351
        ModReceiveOrder({
348
              biblionumber     => $biblionumber,
352
              biblionumber     => $biblionumber,
349
              ordernumber      => $ordernumber,
353
              ordernumber      => $ordernumber,
(-)a/t/db_dependent/Letters.t (-4 / +4 lines)
Lines 43-48 use_ok('C4::Bookseller'); Link Here
43
use_ok('C4::Letters');
43
use_ok('C4::Letters');
44
use t::lib::Mocks;
44
use t::lib::Mocks;
45
use Koha::DateUtils qw( dt_from_string output_pref );
45
use Koha::DateUtils qw( dt_from_string output_pref );
46
use Koha::Acquisition::Order;
46
47
47
my $dbh = C4::Context->dbh;
48
my $dbh = C4::Context->dbh;
48
49
Lines 295-301 my $budgetid = C4::Budgets::AddBudget({ Link Here
295
    budget_name => "budget_name_test_letters",
296
    budget_name => "budget_name_test_letters",
296
});
297
});
297
298
298
my $ordernumber;
299
my $bib = MARC::Record->new();
299
my $bib = MARC::Record->new();
300
if (C4::Context->preference('marcflavour') eq 'UNIMARC') {
300
if (C4::Context->preference('marcflavour') eq 'UNIMARC') {
301
    $bib->append_fields(
301
    $bib->append_fields(
Lines 308-321 if (C4::Context->preference('marcflavour') eq 'UNIMARC') { Link Here
308
}
308
}
309
309
310
($biblionumber, $biblioitemnumber) = AddBiblio($bib, '');
310
($biblionumber, $biblioitemnumber) = AddBiblio($bib, '');
311
( undef, $ordernumber ) = C4::Acquisition::NewOrder(
311
my $order = Koha::Acquisition::Order->new(
312
    {
312
    {
313
        basketno => $basketno,
313
        basketno => $basketno,
314
        quantity => 1,
314
        quantity => 1,
315
        biblionumber => $biblionumber,
315
        biblionumber => $biblionumber,
316
        budget_id => $budgetid,
316
        budget_id => $budgetid,
317
    }
317
    }
318
);
318
)->insert;
319
my $ordernumber = $order->{ordernumber};
319
320
320
C4::Acquisition::CloseBasket( $basketno );
321
C4::Acquisition::CloseBasket( $basketno );
321
my $err;
322
my $err;
322
- 

Return to bug 12830