C4/Items.pm

   1 package C4::Items;
   2
   3 # Copyright 2007 LibLime, Inc.
   4 # Parts Copyright Biblibre 2010
   5 #
   6 # This file is part of Koha.
   7 #
   8 # Koha is free software; you can redistribute it and/or modify it under the
   9 # terms of the GNU General Public License as published by the Free Software
  10 # Foundation; either version 2 of the License, or (at your option) any later
  11 # version.
  12 #
  13 # Koha is distributed in the hope that it will be useful, but WITHOUT ANY
  14 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  15 # A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License along
  18 # with Koha; if not, write to the Free Software Foundation, Inc.,
  19 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20
  21 use strict;
  22 #use warnings; FIXME - Bug 2505
  23
  24 use Carp;
  25 use C4::Context;
  26 use C4::Koha;
  27 use C4::Biblio;
  28 use C4::Dates qw/format_date format_date_in_iso/;
  29 use MARC::Record;
  30 use C4::ClassSource;
  31 use C4::Log;
  32 use C4::Branch;
  33 require C4::Reserves;
  34 use C4::Charset;
  35 use C4::Acquisition;
  36
  37 use vars qw($VERSION @ISA @EXPORT);
  38
  39 BEGIN {
  40     $VERSION = 3.01;
  41
  42         require Exporter;
  43     @ISA = qw( Exporter );
  44
  45     # function exports
  46     @EXPORT = qw(
  47         GetItem
  48         AddItemFromMarc
  49         AddItem
  50         AddItemBatchFromMarc
  51         ModItemFromMarc
  52                 Item2Marc
  53         ModItem
  54         ModDateLastSeen
  55         ModItemTransfer
  56         DelItem
  57
  58         CheckItemPreSave
  59
  60         GetItemStatus
  61         GetItemLocation
  62         GetLostItems
  63         GetItemsForInventory
  64         GetItemsCount
  65         GetItemInfosOf
  66         GetItemsByBiblioitemnumber
  67         GetItemsInfo
  68         GetItemsLocationInfo
  69         get_itemnumbers_of
  70         GetItemnumberFromBarcode
  71         GetBarcodeFromItemnumber
  72
  73                 DelItemCheck
  74                 MoveItemFromBiblio
  75                 GetLatestAcquisitions
  76         CartToShelf
  77     );
  78 }
  79
  80 =head1 NAME
  81
  82 C4::Items - item management functions
  83
  84 =head1 DESCRIPTION
  85
  86 This module contains an API for manipulating item
  87 records in Koha, and is used by cataloguing, circulation,
  88 acquisitions, and serials management.
  89
  90 A Koha item record is stored in two places: the
  91 items table and embedded in a MARC tag in the XML
  92 version of the associated bib record in C<biblioitems.marcxml>.
  93 This is done to allow the item information to be readily
  94 indexed (e.g., by Zebra), but means that each item
  95 modification transaction must keep the items table
  96 and the MARC XML in sync at all times.
  97
  98 Consequently, all code that creates, modifies, or deletes
  99 item records B<must> use an appropriate function from
 100 C<C4::Items>.  If no existing function is suitable, it is
 101 better to add one to C<C4::Items> than to use add
 102 one-off SQL statements to add or modify items.
 103
 104 The items table will be considered authoritative.  In other
 105 words, if there is ever a discrepancy between the items
 106 table and the MARC XML, the items table should be considered
 107 accurate.
 108
 109 =head1 HISTORICAL NOTE
 110
 111 Most of the functions in C<C4::Items> were originally in
 112 the C<C4::Biblio> module.
 113
 114 =head1 CORE EXPORTED FUNCTIONS
 115
 116 The following functions are meant for use by users
 117 of C<C4::Items>
 118
 119 =cut
 120
 121 =head2 GetItem
 122
 123   $item = GetItem($itemnumber,$barcode,$serial);
 124
 125 Return item information, for a given itemnumber or barcode.
 126 The return value is a hashref mapping item column
 127 names to values.  If C<$serial> is true, include serial publication data.
 128
 129 =cut
 130
 131 sub GetItem {
 132     my ($itemnumber,$barcode, $serial) = @_;
 133     my $dbh = C4::Context->dbh;
 134         my $data;
 135     if ($itemnumber) {
 136         my $sth = $dbh->prepare("
 137             SELECT * FROM items
 138             WHERE itemnumber = ?");
 139         $sth->execute($itemnumber);
 140         $data = $sth->fetchrow_hashref;
 141     } else {
 142         my $sth = $dbh->prepare("
 143             SELECT * FROM items
 144             WHERE barcode = ?"
 145             );
 146         $sth->execute($barcode);
 147         $data = $sth->fetchrow_hashref;
 148     }
 149     if ( $serial) {
 150     my $ssth = $dbh->prepare("SELECT serialseq,publisheddate from serialitems left join serial on serialitems.serialid=serial.serialid where serialitems.itemnumber=?");
 151         $ssth->execute($data->{'itemnumber'}) ;
 152         ($data->{'serialseq'} , $data->{'publisheddate'}) = $ssth->fetchrow_array();
 153     }
 154         #if we don't have an items.itype, use biblioitems.itemtype.
 155         if( ! $data->{'itype'} ) {
 156                 my $sth = $dbh->prepare("SELECT itemtype FROM biblioitems  WHERE biblionumber = ?");
 157                 $sth->execute($data->{'biblionumber'});
 158                 ($data->{'itype'}) = $sth->fetchrow_array;
 159         }
 160     return $data;
 161 }    # sub GetItem
 162
 163 =head2 CartToShelf
 164
 165   CartToShelf($itemnumber);
 166
 167 Set the current shelving location of the item record
 168 to its stored permanent shelving location.  This is
 169 primarily used to indicate when an item whose current
 170 location is a special processing ('PROC') or shelving cart
 171 ('CART') location is back in the stacks.
 172
 173 =cut
 174
 175 sub CartToShelf {
 176     my ( $itemnumber ) = @_;
 177
 178     unless ( $itemnumber ) {
 179         croak "FAILED CartToShelf() - no itemnumber supplied";
 180     }
 181
 182     my $item = GetItem($itemnumber);
 183     $item->{location} = $item->{permanent_location};
 184     ModItem($item, undef, $itemnumber);
 185 }
 186
 187 =head2 AddItemFromMarc
 188
 189   my ($biblionumber, $biblioitemnumber, $itemnumber)
 190       = AddItemFromMarc($source_item_marc, $biblionumber);
 191
 192 Given a MARC::Record object containing an embedded item
 193 record and a biblionumber, create a new item record.
 194
 195 =cut
 196
 197 sub AddItemFromMarc {
 198     my ( $source_item_marc, $biblionumber ) = @_;
 199     my $dbh = C4::Context->dbh;
 200
 201     # parse item hash from MARC
 202     my $frameworkcode = GetFrameworkCode( $biblionumber );
 203         my ($itemtag,$itemsubfield)=GetMarcFromKohaField("items.itemnumber",$frameworkcode);
 204
 205         my $localitemmarc=MARC::Record->new;
 206         $localitemmarc->append_fields($source_item_marc->field($itemtag));
 207     my $item = &TransformMarcToKoha( $dbh, $localitemmarc, $frameworkcode ,'items');
 208     my $unlinked_item_subfields = _get_unlinked_item_subfields($localitemmarc, $frameworkcode);
 209     return AddItem($item, $biblionumber, $dbh, $frameworkcode, $unlinked_item_subfields);
 210 }
 211
 212 =head2 AddItem
 213
 214   my ($biblionumber, $biblioitemnumber, $itemnumber)
 215       = AddItem($item, $biblionumber[, $dbh, $frameworkcode, $unlinked_item_subfields]);
 216
 217 Given a hash containing item column names as keys,
 218 create a new Koha item record.
 219
 220 The first two optional parameters (C<$dbh> and C<$frameworkcode>)
 221 do not need to be supplied for general use; they exist
 222 simply to allow them to be picked up from AddItemFromMarc.
 223
 224 The final optional parameter, C<$unlinked_item_subfields>, contains
 225 an arrayref containing subfields present in the original MARC
 226 representation of the item (e.g., from the item editor) that are
 227 not mapped to C<items> columns directly but should instead
 228 be stored in C<items.more_subfields_xml> and included in
 229 the biblio items tag for display and indexing.
 230
 231 =cut
 232
 233 sub AddItem {
 234     my $item = shift;
 235     my $biblionumber = shift;
 236
 237     my $dbh           = @_ ? shift : C4::Context->dbh;
 238     my $frameworkcode = @_ ? shift : GetFrameworkCode( $biblionumber );
 239     my $unlinked_item_subfields;
 240     if (@_) {
 241         $unlinked_item_subfields = shift
 242     };
 243
 244     # needs old biblionumber and biblioitemnumber
 245     $item->{'biblionumber'} = $biblionumber;
 246     my $sth = $dbh->prepare("SELECT biblioitemnumber FROM biblioitems WHERE biblionumber=?");
 247     $sth->execute( $item->{'biblionumber'} );
 248     ($item->{'biblioitemnumber'}) = $sth->fetchrow;
 249
 250     _set_defaults_for_add($item);
 251     _set_derived_columns_for_add($item);
 252     $item->{'more_subfields_xml'} = _get_unlinked_subfields_xml($unlinked_item_subfields);
 253     # FIXME - checks here
 254     unless ( $item->{itype} ) {  # default to biblioitem.itemtype if no itype
 255         my $itype_sth = $dbh->prepare("SELECT itemtype FROM biblioitems WHERE biblionumber = ?");
 256         $itype_sth->execute( $item->{'biblionumber'} );
 257         ( $item->{'itype'} ) = $itype_sth->fetchrow_array;
 258     }
 259
 260         my ( $itemnumber, $error ) = _koha_new_item( $item, $item->{barcode} );
 261     $item->{'itemnumber'} = $itemnumber;
 262
 263     # create MARC tag representing item and add to bib
 264     my $new_item_marc = _marc_from_item_hash($item, $frameworkcode, $unlinked_item_subfields);
 265     _add_item_field_to_biblio($new_item_marc, $item->{'biblionumber'}, $frameworkcode );
 266
 267     logaction("CATALOGUING", "ADD", $itemnumber, "item") if C4::Context->preference("CataloguingLog");
 268
 269     return ($item->{biblionumber}, $item->{biblioitemnumber}, $itemnumber);
 270 }
 271
 272 =head2 AddItemBatchFromMarc
 273
 274   ($itemnumber_ref, $error_ref) = AddItemBatchFromMarc($record,
 275              $biblionumber, $biblioitemnumber, $frameworkcode);
 276
 277 Efficiently create item records from a MARC biblio record with
 278 embedded item fields.  This routine is suitable for batch jobs.
 279
 280 This API assumes that the bib record has already been
 281 saved to the C<biblio> and C<biblioitems> tables.  It does
 282 not expect that C<biblioitems.marc> and C<biblioitems.marcxml>
 283 are populated, but it will do so via a call to ModBibiloMarc.
 284
 285 The goal of this API is to have a similar effect to using AddBiblio
 286 and AddItems in succession, but without inefficient repeated
 287 parsing of the MARC XML bib record.
 288
 289 This function returns an arrayref of new itemsnumbers and an arrayref of item
 290 errors encountered during the processing.  Each entry in the errors
 291 list is a hashref containing the following keys:
 292
 293 =over
 294
 295 =item item_sequence
 296
 297 Sequence number of original item tag in the MARC record.
 298
 299 =item item_barcode
 300
 301 Item barcode, provide to assist in the construction of
 302 useful error messages.
 303
 304 =item error_condition
 305
 306 Code representing the error condition.  Can be 'duplicate_barcode',
 307 'invalid_homebranch', or 'invalid_holdingbranch'.
 308
 309 =item error_information
 310
 311 Additional information appropriate to the error condition.
 312
 313 =back
 314
 315 =cut
 316
 317 sub AddItemBatchFromMarc {
 318     my ($record, $biblionumber, $biblioitemnumber, $frameworkcode) = @_;
 319     my $error;
 320     my @itemnumbers = ();
 321     my @errors = ();
 322     my $dbh = C4::Context->dbh;
 323
 324     # loop through the item tags and start creating items
 325     my @bad_item_fields = ();
 326     my ($itemtag, $itemsubfield) = &GetMarcFromKohaField("items.itemnumber",'');
 327     my $item_sequence_num = 0;
 328     ITEMFIELD: foreach my $item_field ($record->field($itemtag)) {
 329         $item_sequence_num++;
 330         # we take the item field and stick it into a new
 331         # MARC record -- this is required so far because (FIXME)
 332         # TransformMarcToKoha requires a MARC::Record, not a MARC::Field
 333         # and there is no TransformMarcFieldToKoha
 334         my $temp_item_marc = MARC::Record->new();
 335         $temp_item_marc->append_fields($item_field);
 336
 337         # add biblionumber and biblioitemnumber
 338         my $item = TransformMarcToKoha( $dbh, $temp_item_marc, $frameworkcode, 'items' );
 339         my $unlinked_item_subfields = _get_unlinked_item_subfields($temp_item_marc, $frameworkcode);
 340         $item->{'more_subfields_xml'} = _get_unlinked_subfields_xml($unlinked_item_subfields);
 341         $item->{'biblionumber'} = $biblionumber;
 342         $item->{'biblioitemnumber'} = $biblioitemnumber;
 343
 344         # check for duplicate barcode
 345         my %item_errors = CheckItemPreSave($item);
 346         if (%item_errors) {
 347             push @errors, _repack_item_errors($item_sequence_num, $item, \%item_errors);
 348             push @bad_item_fields, $item_field;
 349             next ITEMFIELD;
 350         }
 351
 352         _set_defaults_for_add($item);
 353         _set_derived_columns_for_add($item);
 354         my ( $itemnumber, $error ) = _koha_new_item( $item, $item->{barcode} );
 355         warn $error if $error;
 356         push @itemnumbers, $itemnumber; # FIXME not checking error
 357         $item->{'itemnumber'} = $itemnumber;
 358
 359         logaction("CATALOGUING", "ADD", $itemnumber, "item") if C4::Context->preference("CataloguingLog");
 360
 361         my $new_item_marc = _marc_from_item_hash($item, $frameworkcode, $unlinked_item_subfields);
 362         $item_field->replace_with($new_item_marc->field($itemtag));
 363     }
 364
 365     # remove any MARC item fields for rejected items
 366     foreach my $item_field (@bad_item_fields) {
 367         $record->delete_field($item_field);
 368     }
 369
 370     # update the MARC biblio
 371     $biblionumber = ModBiblioMarc( $record, $biblionumber, $frameworkcode );
 372
 373     return (\@itemnumbers, \@errors);
 374 }
 375
 376 =head2 ModItemFromMarc
 377
 378   ModItemFromMarc($item_marc, $biblionumber, $itemnumber);
 379
 380 This function updates an item record based on a supplied
 381 C<MARC::Record> object containing an embedded item field.
 382 This API is meant for the use of C<additem.pl>; for
 383 other purposes, C<ModItem> should be used.
 384
 385 This function uses the hash %default_values_for_mod_from_marc,
 386 which contains default values for item fields to
 387 apply when modifying an item.  This is needed beccause
 388 if an item field's value is cleared, TransformMarcToKoha
 389 does not include the column in the
 390 hash that's passed to ModItem, which without
 391 use of this hash makes it impossible to clear
 392 an item field's value.  See bug 2466.
 393
 394 Note that only columns that can be directly
 395 changed from the cataloging and serials
 396 item editors are included in this hash.
 397
 398 =cut
 399
 400 my %default_values_for_mod_from_marc = (
 401     barcode              => undef,
 402     booksellerid         => undef,
 403     ccode                => undef,
 404     'items.cn_source'    => undef,
 405     copynumber           => undef,
 406     damaged              => 0,
 407 #    dateaccessioned      => undef,
 408     enumchron            => undef,
 409     holdingbranch        => undef,
 410     homebranch           => undef,
 411     itemcallnumber       => undef,
 412     itemlost             => 0,
 413     itemnotes            => undef,
 414     itype                => undef,
 415     location             => undef,
 416     materials            => undef,
 417     notforloan           => 0,
 418     paidfor              => undef,
 419     price                => undef,
 420     replacementprice     => undef,
 421     replacementpricedate => undef,
 422     restricted           => undef,
 423     stack                => undef,
 424     stocknumber          => undef,
 425     uri                  => undef,
 426     wthdrawn             => 0,
 427 );
 428
 429 sub ModItemFromMarc {
 430     my $item_marc = shift;
 431     my $biblionumber = shift;
 432     my $itemnumber = shift;
 433
 434     my $dbh           = C4::Context->dbh;
 435     my $frameworkcode = GetFrameworkCode($biblionumber);
 436     my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField( "items.itemnumber", $frameworkcode );
 437
 438     my $localitemmarc = MARC::Record->new;
 439     $localitemmarc->append_fields( $item_marc->field($itemtag) );
 440     my $item = &TransformMarcToKoha( $dbh, $localitemmarc, $frameworkcode, 'items' );
 441     foreach my $item_field ( keys %default_values_for_mod_from_marc ) {
 442         $item->{$item_field} = $default_values_for_mod_from_marc{$item_field} unless (exists $item->{$item_field});
 443     }
 444     my $unlinked_item_subfields = _get_unlinked_item_subfields( $localitemmarc, $frameworkcode );
 445
 446     return ModItem($item, $biblionumber, $itemnumber, $dbh, $frameworkcode, $unlinked_item_subfields);
 447 }
 448
 449 =head2 ModItem
 450
 451   ModItem({ column => $newvalue }, $biblionumber,
 452                   $itemnumber[, $original_item_marc]);
 453
 454 Change one or more columns in an item record and update
 455 the MARC representation of the item.
 456
 457 The first argument is a hashref mapping from item column
 458 names to the new values.  The second and third arguments
 459 are the biblionumber and itemnumber, respectively.
 460
 461 The fourth, optional parameter, C<$unlinked_item_subfields>, contains
 462 an arrayref containing subfields present in the original MARC
 463 representation of the item (e.g., from the item editor) that are
 464 not mapped to C<items> columns directly but should instead
 465 be stored in C<items.more_subfields_xml> and included in
 466 the biblio items tag for display and indexing.
 467
 468 If one of the changed columns is used to calculate
 469 the derived value of a column such as C<items.cn_sort>,
 470 this routine will perform the necessary calculation
 471 and set the value.
 472
 473 =cut
 474
 475 sub ModItem {
 476     my $item = shift;
 477     my $biblionumber = shift;
 478     my $itemnumber = shift;
 479
 480     # if $biblionumber is undefined, get it from the current item
 481     unless (defined $biblionumber) {
 482         $biblionumber = _get_single_item_column('biblionumber', $itemnumber);
 483     }
 484
 485     my $dbh           = @_ ? shift : C4::Context->dbh;
 486     my $frameworkcode = @_ ? shift : GetFrameworkCode( $biblionumber );
 487
 488     my $unlinked_item_subfields;
 489     if (@_) {
 490         $unlinked_item_subfields = shift;
 491         $item->{'more_subfields_xml'} = _get_unlinked_subfields_xml($unlinked_item_subfields);
 492     };
 493
 494     $item->{'itemnumber'} = $itemnumber or return undef;
 495     _set_derived_columns_for_mod($item);
 496     _do_column_fixes_for_mod($item);
 497     # FIXME add checks
 498     # duplicate barcode
 499     # attempt to change itemnumber
 500     # attempt to change biblionumber (if we want
 501     # an API to relink an item to a different bib,
 502     # it should be a separate function)
 503
 504     # update items table
 505     _koha_modify_item($item);
 506
 507     # update biblio MARC XML
 508     my $whole_item = GetItem($itemnumber) or die "FAILED GetItem($itemnumber)";
 509
 510     unless (defined $unlinked_item_subfields) {
 511         $unlinked_item_subfields = _parse_unlinked_item_subfields_from_xml($whole_item->{'more_subfields_xml'});
 512     }
 513     my $new_item_marc = _marc_from_item_hash($whole_item, $frameworkcode, $unlinked_item_subfields)
 514         or die "FAILED _marc_from_item_hash($whole_item, $frameworkcode)";
 515
 516     _replace_item_field_in_biblio($new_item_marc, $biblionumber, $itemnumber, $frameworkcode);
 517         ($new_item_marc       eq '0') and die "$new_item_marc is '0', not hashref";  # logaction line would crash anyway
 518     logaction("CATALOGUING", "MODIFY", $itemnumber, $new_item_marc->as_formatted) if C4::Context->preference("CataloguingLog");
 519 }
 520
 521 =head2 ModItemTransfer
 522
 523   ModItemTransfer($itenumber, $frombranch, $tobranch);
 524
 525 Marks an item as being transferred from one branch
 526 to another.
 527
 528 =cut
 529
 530 sub ModItemTransfer {
 531     my ( $itemnumber, $frombranch, $tobranch ) = @_;
 532
 533     my $dbh = C4::Context->dbh;
 534
 535     #new entry in branchtransfers....
 536     my $sth = $dbh->prepare(
 537         "INSERT INTO branchtransfers (itemnumber, frombranch, datesent, tobranch)
 538         VALUES (?, ?, NOW(), ?)");
 539     $sth->execute($itemnumber, $frombranch, $tobranch);
 540
 541     ModItem({ holdingbranch => $tobranch }, undef, $itemnumber);
 542     ModDateLastSeen($itemnumber);
 543     return;
 544 }
 545
 546 =head2 ModDateLastSeen
 547
 548   ModDateLastSeen($itemnum);
 549
 550 Mark item as seen. Is called when an item is issued, returned or manually marked during inventory/stocktaking.
 551 C<$itemnum> is the item number
 552
 553 =cut
 554
 555 sub ModDateLastSeen {
 556     my ($itemnumber) = @_;
 557
 558     my $today = C4::Dates->new();
 559     ModItem({ itemlost => 0, datelastseen => $today->output("iso") }, undef, $itemnumber);
 560 }
 561
 562 =head2 DelItem
 563
 564   DelItem($dbh, $biblionumber, $itemnumber);
 565
 566 Exported function (core API) for deleting an item record in Koha.
 567
 568 =cut
 569
 570 sub DelItem {
 571     my ( $dbh, $biblionumber, $itemnumber ) = @_;
 572
 573     # FIXME check the item has no current issues
 574
 575     _koha_delete_item( $dbh, $itemnumber );
 576
 577     # get the MARC record
 578     my $record = GetMarcBiblio($biblionumber);
 579     my $frameworkcode = GetFrameworkCode($biblionumber);
 580
 581     # backup the record
 582     my $copy2deleted = $dbh->prepare("UPDATE deleteditems SET marc=? WHERE itemnumber=?");
 583     $copy2deleted->execute( $record->as_usmarc(), $itemnumber );
 584
 585     #search item field code
 586     my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField("items.itemnumber",$frameworkcode);
 587     my @fields = $record->field($itemtag);
 588
 589     # delete the item specified
 590     foreach my $field (@fields) {
 591         if ( $field->subfield($itemsubfield) eq $itemnumber ) {
 592             $record->delete_field($field);
 593         }
 594     }
 595     &ModBiblioMarc( $record, $biblionumber, $frameworkcode );
 596     logaction("CATALOGUING", "DELETE", $itemnumber, "item") if C4::Context->preference("CataloguingLog");
 597 }
 598
 599 =head2 CheckItemPreSave
 600
 601     my $item_ref = TransformMarcToKoha($marc, 'items');
 602     # do stuff
 603     my %errors = CheckItemPreSave($item_ref);
 604     if (exists $errors{'duplicate_barcode'}) {
 605         print "item has duplicate barcode: ", $errors{'duplicate_barcode'}, "\n";
 606     } elsif (exists $errors{'invalid_homebranch'}) {
 607         print "item has invalid home branch: ", $errors{'invalid_homebranch'}, "\n";
 608     } elsif (exists $errors{'invalid_holdingbranch'}) {
 609         print "item has invalid holding branch: ", $errors{'invalid_holdingbranch'}, "\n";
 610     } else {
 611         print "item is OK";
 612     }
 613
 614 Given a hashref containing item fields, determine if it can be
 615 inserted or updated in the database.  Specifically, checks for
 616 database integrity issues, and returns a hash containing any
 617 of the following keys, if applicable.
 618
 619 =over 2
 620
 621 =item duplicate_barcode
 622
 623 Barcode, if it duplicates one already found in the database.
 624
 625 =item invalid_homebranch
 626
 627 Home branch, if not defined in branches table.
 628
 629 =item invalid_holdingbranch
 630
 631 Holding branch, if not defined in branches table.
 632
 633 =back
 634
 635 This function does NOT implement any policy-related checks,
 636 e.g., whether current operator is allowed to save an
 637 item that has a given branch code.
 638
 639 =cut
 640
 641 sub CheckItemPreSave {
 642     my $item_ref = shift;
 643
 644     my %errors = ();
 645
 646     # check for duplicate barcode
 647     if (exists $item_ref->{'barcode'} and defined $item_ref->{'barcode'}) {
 648         my $existing_itemnumber = GetItemnumberFromBarcode($item_ref->{'barcode'});
 649         if ($existing_itemnumber) {
 650             if (!exists $item_ref->{'itemnumber'}                       # new item
 651                 or $item_ref->{'itemnumber'} != $existing_itemnumber) { # existing item
 652                 $errors{'duplicate_barcode'} = $item_ref->{'barcode'};
 653             }
 654         }
 655     }
 656
 657     # check for valid home branch
 658     if (exists $item_ref->{'homebranch'} and defined $item_ref->{'homebranch'}) {
 659         my $branch_name = GetBranchName($item_ref->{'homebranch'});
 660         unless (defined $branch_name) {
 661             # relies on fact that branches.branchname is a non-NULL column,
 662             # so GetBranchName returns undef only if branch does not exist
 663             $errors{'invalid_homebranch'} = $item_ref->{'homebranch'};
 664         }
 665     }
 666
 667     # check for valid holding branch
 668     if (exists $item_ref->{'holdingbranch'} and defined $item_ref->{'holdingbranch'}) {
 669         my $branch_name = GetBranchName($item_ref->{'holdingbranch'});
 670         unless (defined $branch_name) {
 671             # relies on fact that branches.branchname is a non-NULL column,
 672             # so GetBranchName returns undef only if branch does not exist
 673             $errors{'invalid_holdingbranch'} = $item_ref->{'holdingbranch'};
 674         }
 675     }
 676
 677     return %errors;
 678
 679 }
 680
 681 =head1 EXPORTED SPECIAL ACCESSOR FUNCTIONS
 682
 683 The following functions provide various ways of
 684 getting an item record, a set of item records, or
 685 lists of authorized values for certain item fields.
 686
 687 Some of the functions in this group are candidates
 688 for refactoring -- for example, some of the code
 689 in C<GetItemsByBiblioitemnumber> and C<GetItemsInfo>
 690 has copy-and-paste work.
 691
 692 =cut
 693
 694 =head2 GetItemStatus
 695
 696   $itemstatushash = GetItemStatus($fwkcode);
 697
 698 Returns a list of valid values for the
 699 C<items.notforloan> field.
 700
 701 NOTE: does B<not> return an individual item's
 702 status.
 703
 704 Can be MARC dependant.
 705 fwkcode is optional.
 706 But basically could be can be loan or not
 707 Create a status selector with the following code
 708
 709 =head3 in PERL SCRIPT
 710
 711  my $itemstatushash = getitemstatus;
 712  my @itemstatusloop;
 713  foreach my $thisstatus (keys %$itemstatushash) {
 714      my %row =(value => $thisstatus,
 715                  statusname => $itemstatushash->{$thisstatus}->{'statusname'},
 716              );
 717      push @itemstatusloop, \%row;
 718  }
 719  $template->param(statusloop=>\@itemstatusloop);
 720
 721 =head3 in TEMPLATE
 722
 723  <select name="statusloop">
 724      <option value="">Default</option>
 725  <!-- TMPL_LOOP name="statusloop" -->
 726      <option value="<!-- TMPL_VAR name="value" -->" <!-- TMPL_IF name="selected" -->selected<!-- /TMPL_IF -->><!-- TMPL_VAR name="statusname" --></option>
 727  <!-- /TMPL_LOOP -->
 728  </select>
 729
 730 =cut
 731
 732 sub GetItemStatus {
 733
 734     # returns a reference to a hash of references to status...
 735     my ($fwk) = @_;
 736     my %itemstatus;
 737     my $dbh = C4::Context->dbh;
 738     my $sth;
 739     $fwk = '' unless ($fwk);
 740     my ( $tag, $subfield ) =
 741       GetMarcFromKohaField( "items.notforloan", $fwk );
 742     if ( $tag and $subfield ) {
 743         my $sth =
 744           $dbh->prepare(
 745             "SELECT authorised_value
 746             FROM marc_subfield_structure
 747             WHERE tagfield=?
 748                 AND tagsubfield=?
 749                 AND frameworkcode=?
 750             "
 751           );
 752         $sth->execute( $tag, $subfield, $fwk );
 753         if ( my ($authorisedvaluecat) = $sth->fetchrow ) {
 754             my $authvalsth =
 755               $dbh->prepare(
 756                 "SELECT authorised_value,lib
 757                 FROM authorised_values
 758                 WHERE category=?
 759                 ORDER BY lib
 760                 "
 761               );
 762             $authvalsth->execute($authorisedvaluecat);
 763             while ( my ( $authorisedvalue, $lib ) = $authvalsth->fetchrow ) {
 764                 $itemstatus{$authorisedvalue} = $lib;
 765             }
 766             return \%itemstatus;
 767             exit 1;
 768         }
 769         else {
 770
 771             #No authvalue list
 772             # build default
 773         }
 774     }
 775
 776     #No authvalue list
 777     #build default
 778     $itemstatus{"1"} = "Not For Loan";
 779     return \%itemstatus;
 780 }
 781
 782 =head2 GetItemLocation
 783
 784   $itemlochash = GetItemLocation($fwk);
 785
 786 Returns a list of valid values for the
 787 C<items.location> field.
 788
 789 NOTE: does B<not> return an individual item's
 790 location.
 791
 792 where fwk stands for an optional framework code.
 793 Create a location selector with the following code
 794
 795 =head3 in PERL SCRIPT
 796
 797   my $itemlochash = getitemlocation;
 798   my @itemlocloop;
 799   foreach my $thisloc (keys %$itemlochash) {
 800       my $selected = 1 if $thisbranch eq $branch;
 801       my %row =(locval => $thisloc,
 802                   selected => $selected,
 803                   locname => $itemlochash->{$thisloc},
 804                );
 805       push @itemlocloop, \%row;
 806   }
 807   $template->param(itemlocationloop => \@itemlocloop);
 808
 809 =head3 in TEMPLATE
 810
 811   <select name="location">
 812       <option value="">Default</option>
 813   <!-- TMPL_LOOP name="itemlocationloop" -->
 814       <option value="<!-- TMPL_VAR name="locval" -->" <!-- TMPL_IF name="selected" -->selected<!-- /TMPL_IF -->><!-- TMPL_VAR name="locname" --></option>
 815   <!-- /TMPL_LOOP -->
 816   </select>
 817
 818 =cut
 819
 820 sub GetItemLocation {
 821
 822     # returns a reference to a hash of references to location...
 823     my ($fwk) = @_;
 824     my %itemlocation;
 825     my $dbh = C4::Context->dbh;
 826     my $sth;
 827     $fwk = '' unless ($fwk);
 828     my ( $tag, $subfield ) =
 829       GetMarcFromKohaField( "items.location", $fwk );
 830     if ( $tag and $subfield ) {
 831         my $sth =
 832           $dbh->prepare(
 833             "SELECT authorised_value
 834             FROM marc_subfield_structure
 835             WHERE tagfield=?
 836                 AND tagsubfield=?
 837                 AND frameworkcode=?"
 838           );
 839         $sth->execute( $tag, $subfield, $fwk );
 840         if ( my ($authorisedvaluecat) = $sth->fetchrow ) {
 841             my $authvalsth =
 842               $dbh->prepare(
 843                 "SELECT authorised_value,lib
 844                 FROM authorised_values
 845                 WHERE category=?
 846                 ORDER BY lib"
 847               );
 848             $authvalsth->execute($authorisedvaluecat);
 849             while ( my ( $authorisedvalue, $lib ) = $authvalsth->fetchrow ) {
 850                 $itemlocation{$authorisedvalue} = $lib;
 851             }
 852             return \%itemlocation;
 853             exit 1;
 854         }
 855         else {
 856
 857             #No authvalue list
 858             # build default
 859         }
 860     }
 861
 862     #No authvalue list
 863     #build default
 864     $itemlocation{"1"} = "Not For Loan";
 865     return \%itemlocation;
 866 }
 867
 868 =head2 GetLostItems
 869
 870   $items = GetLostItems( $where, $orderby );
 871
 872 This function gets a list of lost items.
 873
 874 =over 2
 875
 876 =item input:
 877
 878 C<$where> is a hashref. it containts a field of the items table as key
 879 and the value to match as value. For example:
 880
 881 { barcode    => 'abc123',
 882   homebranch => 'CPL',    }
 883
 884 C<$orderby> is a field of the items table by which the resultset
 885 should be orderd.
 886
 887 =item return:
 888
 889 C<$items> is a reference to an array full of hashrefs with columns
 890 from the "items" table as keys.
 891
 892 =item usage in the perl script:
 893
 894   my $where = { barcode => '0001548' };
 895   my $items = GetLostItems( $where, "homebranch" );
 896   $template->param( itemsloop => $items );
 897
 898 =back
 899
 900 =cut
 901
 902 sub GetLostItems {
 903     # Getting input args.
 904     my $where   = shift;
 905     my $orderby = shift;
 906     my $dbh     = C4::Context->dbh;
 907
 908     my $query   = "
 909         SELECT *
 910         FROM   items
 911             LEFT JOIN biblio ON (items.biblionumber = biblio.biblionumber)
 912             LEFT JOIN biblioitems ON (items.biblionumber = biblioitems.biblionumber)
 913             LEFT JOIN authorised_values ON (items.itemlost = authorised_values.authorised_value)
 914         WHERE
 915                 authorised_values.category = 'LOST'
 916                 AND itemlost IS NOT NULL
 917                 AND itemlost <> 0
 918     ";
 919     my @query_parameters;
 920     foreach my $key (keys %$where) {
 921         $query .= " AND $key LIKE ?";
 922         push @query_parameters, "%$where->{$key}%";
 923     }
 924     my @ordervalues = qw/title author homebranch itype barcode price replacementprice lib datelastseen location/;
 925
 926     if ( defined $orderby && grep($orderby, @ordervalues)) {
 927         $query .= ' ORDER BY '.$orderby;
 928     }
 929
 930     my $sth = $dbh->prepare($query);
 931     $sth->execute( @query_parameters );
 932     my $items = [];
 933     while ( my $row = $sth->fetchrow_hashref ){
 934         push @$items, $row;
 935     }
 936     return $items;
 937 }
 938
 939 =head2 GetItemsForInventory
 940
 941   $itemlist = GetItemsForInventory($minlocation, $maxlocation,
 942                  $location, $itemtype $datelastseen, $branch,
 943                  $offset, $size, $statushash);
 944
 945 Retrieve a list of title/authors/barcode/callnumber, for biblio inventory.
 946
 947 The sub returns a reference to a list of hashes, each containing
 948 itemnumber, author, title, barcode, item callnumber, and date last
 949 seen. It is ordered by callnumber then title.
 950
 951 The required minlocation & maxlocation parameters are used to specify a range of item callnumbers
 952 the datelastseen can be used to specify that you want to see items not seen since a past date only.
 953 offset & size can be used to retrieve only a part of the whole listing (defaut behaviour)
 954 $statushash requires a hashref that has the authorized values fieldname (intems.notforloan, etc...) as keys, and an arrayref of statuscodes we are searching for as values.
 955
 956 =cut
 957
 958 sub GetItemsForInventory {
 959     my ( $minlocation, $maxlocation,$location, $itemtype, $ignoreissued, $datelastseen, $branchcode, $branch, $offset, $size, $statushash ) = @_;
 960     my $dbh = C4::Context->dbh;
 961     my ( @bind_params, @where_strings );
 962
 963     my $query = <<'END_SQL';
 964 SELECT items.itemnumber, barcode, itemcallnumber, title, author, biblio.biblionumber, datelastseen
 965 FROM items
 966   LEFT JOIN biblio ON items.biblionumber = biblio.biblionumber
 967   LEFT JOIN biblioitems on items.biblionumber = biblioitems.biblionumber
 968 END_SQL
 969     if ($statushash){
 970         for my $authvfield (keys %$statushash){
 971             if ( scalar @{$statushash->{$authvfield}} > 0 ){
 972                 my $joinedvals = join ',', @{$statushash->{$authvfield}};
 973                 push @where_strings, "$authvfield in (" . $joinedvals . ")";
 974             }
 975         }
 976     }
 977
 978     if ($minlocation) {
 979         push @where_strings, 'itemcallnumber >= ?';
 980         push @bind_params, $minlocation;
 981     }
 982
 983     if ($maxlocation) {
 984         push @where_strings, 'itemcallnumber <= ?';
 985         push @bind_params, $maxlocation;
 986     }
 987
 988     if ($datelastseen) {
 989         $datelastseen = format_date_in_iso($datelastseen);
 990         push @where_strings, '(datelastseen < ? OR datelastseen IS NULL)';
 991         push @bind_params, $datelastseen;
 992     }
 993
 994     if ( $location ) {
 995         push @where_strings, 'items.location = ?';
 996         push @bind_params, $location;
 997     }
 998
 999     if ( $branchcode ) {
1000         if($branch eq "homebranch"){
1001         push @where_strings, 'items.homebranch = ?';
1002         }else{
1003             push @where_strings, 'items.holdingbranch = ?';
1004         }
1005         push @bind_params, $branchcode;
1006     }
1007
1008     if ( $itemtype ) {
1009         push @where_strings, 'biblioitems.itemtype = ?';
1010         push @bind_params, $itemtype;
1011     }
1012
1013     if ( $ignoreissued) {
1014         $query .= "LEFT JOIN issues ON items.itemnumber = issues.itemnumber ";
1015         push @where_strings, 'issues.date_due IS NULL';
1016     }
1017
1018     if ( @where_strings ) {
1019         $query .= 'WHERE ';
1020         $query .= join ' AND ', @where_strings;
1021     }
1022     $query .= ' ORDER BY items.cn_sort, itemcallnumber, title';
1023     my $sth = $dbh->prepare($query);
1024     $sth->execute( @bind_params );
1025
1026     my @results;
1027     $size--;
1028     while ( my $row = $sth->fetchrow_hashref ) {
1029         $offset-- if ($offset);
1030         $row->{datelastseen}=format_date($row->{datelastseen});
1031         if ( ( !$offset ) && $size ) {
1032             push @results, $row;
1033             $size--;
1034         }
1035     }
1036     return \@results;
1037 }
1038
1039 =head2 GetItemsCount
1040
1041   $count = &GetItemsCount( $biblionumber);
1042
1043 This function return count of item with $biblionumber
1044
1045 =cut
1046
1047 sub GetItemsCount {
1048     my ( $biblionumber ) = @_;
1049     my $dbh = C4::Context->dbh;
1050     my $query = "SELECT count(*)
1051           FROM  items
1052           WHERE biblionumber=?";
1053     my $sth = $dbh->prepare($query);
1054     $sth->execute($biblionumber);
1055     my $count = $sth->fetchrow;
1056     return ($count);
1057 }
1058
1059 =head2 GetItemInfosOf
1060
1061   GetItemInfosOf(@itemnumbers);
1062
1063 =cut
1064
1065 sub GetItemInfosOf {
1066     my @itemnumbers = @_;
1067
1068     my $query = '
1069         SELECT *
1070         FROM items
1071         WHERE itemnumber IN (' . join( ',', @itemnumbers ) . ')
1072     ';
1073     return get_infos_of( $query, 'itemnumber' );
1074 }
1075
1076 =head2 GetItemsByBiblioitemnumber
1077
1078   GetItemsByBiblioitemnumber($biblioitemnumber);
1079
1080 Returns an arrayref of hashrefs suitable for use in a TMPL_LOOP
1081 Called by C<C4::XISBN>
1082
1083 =cut
1084
1085 sub GetItemsByBiblioitemnumber {
1086     my ( $bibitem ) = @_;
1087     my $dbh = C4::Context->dbh;
1088     my $sth = $dbh->prepare("SELECT * FROM items WHERE items.biblioitemnumber = ?") || die $dbh->errstr;
1089     # Get all items attached to a biblioitem
1090     my $i = 0;
1091     my @results;
1092     $sth->execute($bibitem) || die $sth->errstr;
1093     while ( my $data = $sth->fetchrow_hashref ) {
1094         # Foreach item, get circulation information
1095         my $sth2 = $dbh->prepare( "SELECT * FROM issues,borrowers
1096                                    WHERE itemnumber = ?
1097                                    AND issues.borrowernumber = borrowers.borrowernumber"
1098         );
1099         $sth2->execute( $data->{'itemnumber'} );
1100         if ( my $data2 = $sth2->fetchrow_hashref ) {
1101             # if item is out, set the due date and who it is out too
1102             $data->{'date_due'}   = $data2->{'date_due'};
1103             $data->{'cardnumber'} = $data2->{'cardnumber'};
1104             $data->{'borrowernumber'}   = $data2->{'borrowernumber'};
1105         }
1106         else {
1107             # set date_due to blank, so in the template we check itemlost, and wthdrawn
1108             $data->{'date_due'} = '';
1109         }    # else
1110         # Find the last 3 people who borrowed this item.
1111         my $query2 = "SELECT * FROM old_issues, borrowers WHERE itemnumber = ?
1112                       AND old_issues.borrowernumber = borrowers.borrowernumber
1113                       ORDER BY returndate desc,timestamp desc LIMIT 3";
1114         $sth2 = $dbh->prepare($query2) || die $dbh->errstr;
1115         $sth2->execute( $data->{'itemnumber'} ) || die $sth2->errstr;
1116         my $i2 = 0;
1117         while ( my $data2 = $sth2->fetchrow_hashref ) {
1118             $data->{"timestamp$i2"} = $data2->{'timestamp'};
1119             $data->{"card$i2"}      = $data2->{'cardnumber'};
1120             $data->{"borrower$i2"}  = $data2->{'borrowernumber'};
1121             $i2++;
1122         }
1123         push(@results,$data);
1124     }
1125     return (\@results);
1126 }
1127
1128 =head2 GetItemsInfo
1129
1130   @results = GetItemsInfo($biblionumber, $type);
1131
1132 Returns information about books with the given biblionumber.
1133
1134 C<$type> may be either C<intra> or anything else. If it is not set to
1135 C<intra>, then the search will exclude lost, very overdue, and
1136 withdrawn items.
1137
1138 C<GetItemsInfo> returns a list of references-to-hash. Each element
1139 contains a number of keys. Most of them are table items from the
1140 C<biblio>, C<biblioitems>, C<items>, and C<itemtypes> tables in the
1141 Koha database. Other keys include:
1142
1143 =over 2
1144
1145 =item C<$data-E<gt>{branchname}>
1146
1147 The name (not the code) of the branch to which the book belongs.
1148
1149 =item C<$data-E<gt>{datelastseen}>
1150
1151 This is simply C<items.datelastseen>, except that while the date is
1152 stored in YYYY-MM-DD format in the database, here it is converted to
1153 DD/MM/YYYY format. A NULL date is returned as C<//>.
1154
1155 =item C<$data-E<gt>{datedue}>
1156
1157 =item C<$data-E<gt>{class}>
1158
1159 This is the concatenation of C<biblioitems.classification>, the book's
1160 Dewey code, and C<biblioitems.subclass>.
1161
1162 =item C<$data-E<gt>{ocount}>
1163
1164 I think this is the number of copies of the book available.
1165
1166 =item C<$data-E<gt>{order}>
1167
1168 If this is set, it is set to C<One Order>.
1169
1170 =back
1171
1172 =cut
1173
1174 sub GetItemsInfo {
1175     my ( $biblionumber, $type ) = @_;
1176     my $dbh   = C4::Context->dbh;
1177     # note biblioitems.* must be avoided to prevent large marc and marcxml fields from killing performance.
1178     my $query = "
1179     SELECT items.*,
1180            biblio.*,
1181            biblioitems.volume,
1182            biblioitems.number,
1183            biblioitems.itemtype,
1184            biblioitems.isbn,
1185            biblioitems.issn,
1186            biblioitems.publicationyear,
1187            biblioitems.publishercode,
1188            biblioitems.volumedate,
1189            biblioitems.volumedesc,
1190            biblioitems.lccn,
1191            biblioitems.url,
1192            items.notforloan as itemnotforloan,
1193            itemtypes.description,
1194            itemtypes.notforloan as notforloan_per_itemtype,
1195            branchurl
1196      FROM items
1197      LEFT JOIN branches ON items.homebranch = branches.branchcode
1198      LEFT JOIN biblio      ON      biblio.biblionumber     = items.biblionumber
1199      LEFT JOIN biblioitems ON biblioitems.biblioitemnumber = items.biblioitemnumber
1200      LEFT JOIN itemtypes   ON   itemtypes.itemtype         = "
1201      . (C4::Context->preference('item-level_itypes') ? 'items.itype' : 'biblioitems.itemtype');
1202     $query .= " WHERE items.biblionumber = ? ORDER BY branches.branchname,items.dateaccessioned desc" ;
1203     my $sth = $dbh->prepare($query);
1204     $sth->execute($biblionumber);
1205     my $i = 0;
1206     my @results;
1207     my $serial;
1208
1209     my $isth    = $dbh->prepare(
1210         "SELECT issues.*,borrowers.cardnumber,borrowers.surname,borrowers.firstname,borrowers.branchcode as bcode
1211         FROM   issues LEFT JOIN borrowers ON issues.borrowernumber=borrowers.borrowernumber
1212         WHERE  itemnumber = ?"
1213        );
1214         my $ssth = $dbh->prepare("SELECT serialseq,publisheddate from serialitems left join serial on serialitems.serialid=serial.serialid where serialitems.itemnumber=? ");
1215         while ( my $data = $sth->fetchrow_hashref ) {
1216         my $datedue = '';
1217         my $count_reserves;
1218         $isth->execute( $data->{'itemnumber'} );
1219         if ( my $idata = $isth->fetchrow_hashref ) {
1220             $data->{borrowernumber} = $idata->{borrowernumber};
1221             $data->{cardnumber}     = $idata->{cardnumber};
1222             $data->{surname}     = $idata->{surname};
1223             $data->{firstname}     = $idata->{firstname};
1224             $datedue                = $idata->{'date_due'};
1225         if (C4::Context->preference("IndependantBranches")){
1226         my $userenv = C4::Context->userenv;
1227         if ( ($userenv) && ( $userenv->{flags} % 2 != 1 ) ) {
1228             $data->{'NOTSAMEBRANCH'} = 1 if ($idata->{'bcode'} ne $userenv->{branch});
1229         }
1230         }
1231         }
1232                 if ( $data->{'serial'}) {
1233                         $ssth->execute($data->{'itemnumber'}) ;
1234                         ($data->{'serialseq'} , $data->{'publisheddate'}) = $ssth->fetchrow_array();
1235                         $serial = 1;
1236         }
1237                 if ( $datedue eq '' ) {
1238             my ( $restype, $reserves ) =
1239               C4::Reserves::CheckReserves( $data->{'itemnumber'} );
1240 # Previous conditional check with if ($restype) is not needed because a true
1241 # result for one item will result in subsequent items defaulting to this true
1242 # value.
1243             $count_reserves = $restype;
1244         }
1245         #get branch information.....
1246         my $bsth = $dbh->prepare(
1247             "SELECT * FROM branches WHERE branchcode = ?
1248         "
1249         );
1250         $bsth->execute( $data->{'holdingbranch'} );
1251         if ( my $bdata = $bsth->fetchrow_hashref ) {
1252             $data->{'branchname'} = $bdata->{'branchname'};
1253         }
1254         $data->{'datedue'}        = $datedue;
1255         $data->{'count_reserves'} = $count_reserves;
1256
1257         # get notforloan complete status if applicable
1258         my $sthnflstatus = $dbh->prepare(
1259             'SELECT authorised_value
1260             FROM   marc_subfield_structure
1261             WHERE  kohafield="items.notforloan"
1262         '
1263         );
1264
1265         $sthnflstatus->execute;
1266         my ($authorised_valuecode) = $sthnflstatus->fetchrow;
1267         if ($authorised_valuecode) {
1268             $sthnflstatus = $dbh->prepare(
1269                 "SELECT lib FROM authorised_values
1270                  WHERE  category=?
1271                  AND authorised_value=?"
1272             );
1273             $sthnflstatus->execute( $authorised_valuecode,
1274                 $data->{itemnotforloan} );
1275             my ($lib) = $sthnflstatus->fetchrow;
1276             $data->{notforloanvalue} = $lib;
1277         }
1278
1279         # get restricted status and description if applicable
1280         my $restrictedstatus = $dbh->prepare(
1281             'SELECT authorised_value
1282             FROM   marc_subfield_structure
1283             WHERE  kohafield="items.restricted"
1284         '
1285         );
1286
1287         $restrictedstatus->execute;
1288         ($authorised_valuecode) = $restrictedstatus->fetchrow;
1289         if ($authorised_valuecode) {
1290             $restrictedstatus = $dbh->prepare(
1291                 "SELECT lib,lib_opac FROM authorised_values
1292                  WHERE  category=?
1293                  AND authorised_value=?"
1294             );
1295             $restrictedstatus->execute( $authorised_valuecode,
1296                 $data->{restricted} );
1297
1298             if ( my $rstdata = $restrictedstatus->fetchrow_hashref ) {
1299                 $data->{restricted} = $rstdata->{'lib'};
1300                 $data->{restrictedopac} = $rstdata->{'lib_opac'};
1301             }
1302         }
1303
1304         # my stack procedures
1305         my $stackstatus = $dbh->prepare(
1306             'SELECT authorised_value
1307              FROM   marc_subfield_structure
1308              WHERE  kohafield="items.stack"
1309         '
1310         );
1311         $stackstatus->execute;
1312
1313         ($authorised_valuecode) = $stackstatus->fetchrow;
1314         if ($authorised_valuecode) {
1315             $stackstatus = $dbh->prepare(
1316                 "SELECT lib
1317                  FROM   authorised_values
1318                  WHERE  category=?
1319                  AND    authorised_value=?
1320             "
1321             );
1322             $stackstatus->execute( $authorised_valuecode, $data->{stack} );
1323             my ($lib) = $stackstatus->fetchrow;
1324             $data->{stack} = $lib;
1325         }
1326         # Find the last 3 people who borrowed this item.
1327         my $sth2 = $dbh->prepare("SELECT * FROM old_issues,borrowers
1328                                     WHERE itemnumber = ?
1329                                     AND old_issues.borrowernumber = borrowers.borrowernumber
1330                                     ORDER BY returndate DESC
1331                                     LIMIT 3");
1332         $sth2->execute($data->{'itemnumber'});
1333         my $ii = 0;
1334         while (my $data2 = $sth2->fetchrow_hashref()) {
1335             $data->{"timestamp$ii"} = $data2->{'timestamp'} if $data2->{'timestamp'};
1336             $data->{"card$ii"}      = $data2->{'cardnumber'} if $data2->{'cardnumber'};
1337             $data->{"borrower$ii"}  = $data2->{'borrowernumber'} if $data2->{'borrowernumber'};
1338             $ii++;
1339         }
1340
1341         $results[$i] = $data;
1342         $i++;
1343     }
1344         if($serial) {
1345                 return( sort { ($b->{'publisheddate'} || $b->{'enumchron'}) cmp ($a->{'publisheddate'} || $a->{'enumchron'}) } @results );
1346         } else {
1347         return (@results);
1348         }
1349 }
1350
1351 =head2 GetItemsLocationInfo
1352
1353   my @itemlocinfo = GetItemsLocationInfo($biblionumber);
1354
1355 Returns the branch names, shelving location and itemcallnumber for each item attached to the biblio in question
1356
1357 C<GetItemsInfo> returns a list of references-to-hash. Data returned:
1358
1359 =over 2
1360
1361 =item C<$data-E<gt>{homebranch}>
1362
1363 Branch Name of the item's homebranch
1364
1365 =item C<$data-E<gt>{holdingbranch}>
1366
1367 Branch Name of the item's holdingbranch
1368
1369 =item C<$data-E<gt>{location}>
1370
1371 Item's shelving location code
1372
1373 =item C<$data-E<gt>{location_intranet}>
1374
1375 The intranet description for the Shelving Location as set in authorised_values 'LOC'
1376
1377 =item C<$data-E<gt>{location_opac}>
1378
1379 The OPAC description for the Shelving Location as set in authorised_values 'LOC'.  Falls back to intranet description if no OPAC
1380 description is set.
1381
1382 =item C<$data-E<gt>{itemcallnumber}>
1383
1384 Item's itemcallnumber
1385
1386 =item C<$data-E<gt>{cn_sort}>
1387
1388 Item's call number normalized for sorting
1389
1390 =back
1391
1392 =cut
1393
1394 sub GetItemsLocationInfo {
1395         my $biblionumber = shift;
1396         my @results;
1397
1398         my $dbh = C4::Context->dbh;
1399         my $query = "SELECT a.branchname as homebranch, b.branchname as holdingbranch,
1400                             location, itemcallnumber, cn_sort
1401                      FROM items, branches as a, branches as b
1402                      WHERE homebranch = a.branchcode AND holdingbranch = b.branchcode
1403                      AND biblionumber = ?
1404                      ORDER BY cn_sort ASC";
1405         my $sth = $dbh->prepare($query);
1406         $sth->execute($biblionumber);
1407
1408         while ( my $data = $sth->fetchrow_hashref ) {
1409              $data->{location_intranet} = GetKohaAuthorisedValueLib('LOC', $data->{location});
1410              $data->{location_opac}= GetKohaAuthorisedValueLib('LOC', $data->{location}, 1);
1411              push @results, $data;
1412         }
1413         return @results;
1414 }
1415
1416
1417 =head2 GetLastAcquisitions
1418
1419   my $lastacq = GetLastAcquisitions({'branches' => ('branch1','branch2'),
1420                                     'itemtypes' => ('BK','BD')}, 10);
1421
1422 =cut
1423
1424 sub  GetLastAcquisitions {
1425         my ($data,$max) = @_;
1426
1427         my $itemtype = C4::Context->preference('item-level_itypes') ? 'itype' : 'itemtype';
1428
1429         my $number_of_branches = @{$data->{branches}};
1430         my $number_of_itemtypes   = @{$data->{itemtypes}};
1431
1432
1433         my @where = ('WHERE 1 ');
1434         $number_of_branches and push @where
1435            , 'AND holdingbranch IN ('
1436            , join(',', ('?') x $number_of_branches )
1437            , ')'
1438          ;
1439
1440         $number_of_itemtypes and push @where
1441            , "AND $itemtype IN ("
1442            , join(',', ('?') x $number_of_itemtypes )
1443            , ')'
1444          ;
1445
1446         my $query = "SELECT biblio.biblionumber as biblionumber, title, dateaccessioned
1447                                  FROM items RIGHT JOIN biblio ON (items.biblionumber=biblio.biblionumber)
1448                                     RIGHT JOIN biblioitems ON (items.biblioitemnumber=biblioitems.biblioitemnumber)
1449                                     @where
1450                                     GROUP BY biblio.biblionumber
1451                                     ORDER BY dateaccessioned DESC LIMIT $max";
1452
1453         my $dbh = C4::Context->dbh;
1454         my $sth = $dbh->prepare($query);
1455
1456     $sth->execute((@{$data->{branches}}, @{$data->{itemtypes}}));
1457
1458         my @results;
1459         while( my $row = $sth->fetchrow_hashref){
1460                 push @results, {date => $row->{dateaccessioned}
1461                                                 , biblionumber => $row->{biblionumber}
1462                                                 , title => $row->{title}};
1463         }
1464
1465         return @results;
1466 }
1467
1468 =head2 get_itemnumbers_of
1469
1470   my @itemnumbers_of = get_itemnumbers_of(@biblionumbers);
1471
1472 Given a list of biblionumbers, return the list of corresponding itemnumbers
1473 for each biblionumber.
1474
1475 Return a reference on a hash where keys are biblionumbers and values are
1476 references on array of itemnumbers.
1477
1478 =cut
1479
1480 sub get_itemnumbers_of {
1481     my @biblionumbers = @_;
1482
1483     my $dbh = C4::Context->dbh;
1484
1485     my $query = '
1486         SELECT itemnumber,
1487             biblionumber
1488         FROM items
1489         WHERE biblionumber IN (?' . ( ',?' x scalar @biblionumbers - 1 ) . ')
1490     ';
1491     my $sth = $dbh->prepare($query);
1492     $sth->execute(@biblionumbers);
1493
1494     my %itemnumbers_of;
1495
1496     while ( my ( $itemnumber, $biblionumber ) = $sth->fetchrow_array ) {
1497         push @{ $itemnumbers_of{$biblionumber} }, $itemnumber;
1498     }
1499
1500     return \%itemnumbers_of;
1501 }
1502
1503 =head2 GetItemnumberFromBarcode
1504
1505   $result = GetItemnumberFromBarcode($barcode);
1506
1507 =cut
1508
1509 sub GetItemnumberFromBarcode {
1510     my ($barcode) = @_;
1511     my $dbh = C4::Context->dbh;
1512
1513     my $rq =
1514       $dbh->prepare("SELECT itemnumber FROM items WHERE items.barcode=?");
1515     $rq->execute($barcode);
1516     my ($result) = $rq->fetchrow;
1517     return ($result);
1518 }
1519
1520 =head2 GetBarcodeFromItemnumber
1521
1522   $result = GetBarcodeFromItemnumber($itemnumber);
1523
1524 =cut
1525
1526 sub GetBarcodeFromItemnumber {
1527     my ($itemnumber) = @_;
1528     my $dbh = C4::Context->dbh;
1529
1530     my $rq =
1531       $dbh->prepare("SELECT barcode FROM items WHERE items.itemnumber=?");
1532     $rq->execute($itemnumber);
1533     my ($result) = $rq->fetchrow;
1534     return ($result);
1535 }
1536
1537 =head3 get_item_authorised_values
1538
1539 find the types and values for all authorised values assigned to this item.
1540
1541 parameters: itemnumber
1542
1543 returns: a hashref malling the authorised value to the value set for this itemnumber
1544
1545     $authorised_values = {
1546              'CCODE'      => undef,
1547              'DAMAGED'    => '0',
1548              'LOC'        => '3',
1549              'LOST'       => '0'
1550              'NOT_LOAN'   => '0',
1551              'RESTRICTED' => undef,
1552              'STACK'      => undef,
1553              'WITHDRAWN'  => '0',
1554              'branches'   => 'CPL',
1555              'cn_source'  => undef,
1556              'itemtypes'  => 'SER',
1557            };
1558
1559 Notes: see C4::Biblio::get_biblio_authorised_values for a similar method at the biblio level.
1560
1561 =cut
1562
1563 sub get_item_authorised_values {
1564     my $itemnumber = shift;
1565
1566     # assume that these entries in the authorised_value table are item level.
1567     my $query = q(SELECT distinct authorised_value, kohafield
1568                     FROM marc_subfield_structure
1569                     WHERE kohafield like 'item%'
1570                       AND authorised_value != '' );
1571
1572     my $itemlevel_authorised_values = C4::Context->dbh->selectall_hashref( $query, 'authorised_value' );
1573     my $iteminfo = GetItem( $itemnumber );
1574     # warn( Data::Dumper->Dump( [ $itemlevel_authorised_values ], [ 'itemlevel_authorised_values' ] ) );
1575     my $return;
1576     foreach my $this_authorised_value ( keys %$itemlevel_authorised_values ) {
1577         my $field = $itemlevel_authorised_values->{ $this_authorised_value }->{'kohafield'};
1578         $field =~ s/^items\.//;
1579         if ( exists $iteminfo->{ $field } ) {
1580             $return->{ $this_authorised_value } = $iteminfo->{ $field };
1581         }
1582     }
1583     # warn( Data::Dumper->Dump( [ $return ], [ 'return' ] ) );
1584     return $return;
1585 }
1586
1587 =head3 get_authorised_value_images
1588
1589 find a list of icons that are appropriate for display based on the
1590 authorised values for a biblio.
1591
1592 parameters: listref of authorised values, such as comes from
1593 get_item_authorised_values or
1594 from C4::Biblio::get_biblio_authorised_values
1595
1596 returns: listref of hashrefs for each image. Each hashref looks like this:
1597
1598       { imageurl => '/intranet-tmpl/prog/img/itemtypeimg/npl/WEB.gif',
1599         label    => '',
1600         category => '',
1601         value    => '', }
1602
1603 Notes: Currently, I put on the full path to the images on the staff
1604 side. This should either be configurable or not done at all. Since I
1605 have to deal with 'intranet' or 'opac' in
1606 get_biblio_authorised_values, perhaps I should be passing it in.
1607
1608 =cut
1609
1610 sub get_authorised_value_images {
1611     my $authorised_values = shift;
1612
1613     my @imagelist;
1614
1615     my $authorised_value_list = GetAuthorisedValues();
1616     # warn ( Data::Dumper->Dump( [ $authorised_value_list ], [ 'authorised_value_list' ] ) );
1617     foreach my $this_authorised_value ( @$authorised_value_list ) {
1618         if ( exists $authorised_values->{ $this_authorised_value->{'category'} }
1619              && $authorised_values->{ $this_authorised_value->{'category'} } eq $this_authorised_value->{'authorised_value'} ) {
1620             # warn ( Data::Dumper->Dump( [ $this_authorised_value ], [ 'this_authorised_value' ] ) );
1621             if ( defined $this_authorised_value->{'imageurl'} ) {
1622                 push @imagelist, { imageurl => C4::Koha::getitemtypeimagelocation( 'intranet', $this_authorised_value->{'imageurl'} ),
1623                                    label    => $this_authorised_value->{'lib'},
1624                                    category => $this_authorised_value->{'category'},
1625                                    value    => $this_authorised_value->{'authorised_value'}, };
1626             }
1627         }
1628     }
1629
1630     # warn ( Data::Dumper->Dump( [ \@imagelist ], [ 'imagelist' ] ) );
1631     return \@imagelist;
1632
1633 }
1634
1635 =head1 LIMITED USE FUNCTIONS
1636
1637 The following functions, while part of the public API,
1638 are not exported.  This is generally because they are
1639 meant to be used by only one script for a specific
1640 purpose, and should not be used in any other context
1641 without careful thought.
1642
1643 =cut
1644
1645 =head2 GetMarcItem
1646
1647   my $item_marc = GetMarcItem($biblionumber, $itemnumber);
1648
1649 Returns MARC::Record of the item passed in parameter.
1650 This function is meant for use only in C<cataloguing/additem.pl>,
1651 where it is needed to support that script's MARC-like
1652 editor.
1653
1654 =cut
1655
1656 sub GetMarcItem {
1657     my ( $biblionumber, $itemnumber ) = @_;
1658
1659     # GetMarcItem has been revised so that it does the following:
1660     #  1. Gets the item information from the items table.
1661     #  2. Converts it to a MARC field for storage in the bib record.
1662     #
1663     # The previous behavior was:
1664     #  1. Get the bib record.
1665     #  2. Return the MARC tag corresponding to the item record.
1666     #
1667     # The difference is that one treats the items row as authoritative,
1668     # while the other treats the MARC representation as authoritative
1669     # under certain circumstances.
1670
1671     my $itemrecord = GetItem($itemnumber);
1672
1673     # Tack on 'items.' prefix to column names so that TransformKohaToMarc will work.
1674     # Also, don't emit a subfield if the underlying field is blank.
1675
1676
1677     return Item2Marc($itemrecord,$biblionumber);
1678
1679 }
1680 sub Item2Marc {
1681         my ($itemrecord,$biblionumber)=@_;
1682     my $mungeditem = {
1683         map {
1684             defined($itemrecord->{$_}) && $itemrecord->{$_} ne '' ? ("items.$_" => $itemrecord->{$_}) : ()
1685         } keys %{ $itemrecord }
1686     };
1687     my $itemmarc = TransformKohaToMarc($mungeditem);
1688     my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField("items.itemnumber",GetFrameworkCode($biblionumber)||'');
1689
1690     my $unlinked_item_subfields = _parse_unlinked_item_subfields_from_xml($mungeditem->{'items.more_subfields_xml'});
1691     if (defined $unlinked_item_subfields and $#$unlinked_item_subfields > -1) {
1692                 foreach my $field ($itemmarc->field($itemtag)){
1693             $field->add_subfields(@$unlinked_item_subfields);
1694         }
1695     }
1696         return $itemmarc;
1697 }
1698
1699 =head1 PRIVATE FUNCTIONS AND VARIABLES
1700
1701 The following functions are not meant to be called
1702 directly, but are documented in order to explain
1703 the inner workings of C<C4::Items>.
1704
1705 =cut
1706
1707 =head2 %derived_columns
1708
1709 This hash keeps track of item columns that
1710 are strictly derived from other columns in
1711 the item record and are not meant to be set
1712 independently.
1713
1714 Each key in the hash should be the name of a
1715 column (as named by TransformMarcToKoha).  Each
1716 value should be hashref whose keys are the
1717 columns on which the derived column depends.  The
1718 hashref should also contain a 'BUILDER' key
1719 that is a reference to a sub that calculates
1720 the derived value.
1721
1722 =cut
1723
1724 my %derived_columns = (
1725     'items.cn_sort' => {
1726         'itemcallnumber' => 1,
1727         'items.cn_source' => 1,
1728         'BUILDER' => \&_calc_items_cn_sort,
1729     }
1730 );
1731
1732 =head2 _set_derived_columns_for_add
1733
1734   _set_derived_column_for_add($item);
1735
1736 Given an item hash representing a new item to be added,
1737 calculate any derived columns.  Currently the only
1738 such column is C<items.cn_sort>.
1739
1740 =cut
1741
1742 sub _set_derived_columns_for_add {
1743     my $item = shift;
1744
1745     foreach my $column (keys %derived_columns) {
1746         my $builder = $derived_columns{$column}->{'BUILDER'};
1747         my $source_values = {};
1748         foreach my $source_column (keys %{ $derived_columns{$column} }) {
1749             next if $source_column eq 'BUILDER';
1750             $source_values->{$source_column} = $item->{$source_column};
1751         }
1752         $builder->($item, $source_values);
1753     }
1754 }
1755
1756 =head2 _set_derived_columns_for_mod
1757
1758   _set_derived_column_for_mod($item);
1759
1760 Given an item hash representing a new item to be modified.
1761 calculate any derived columns.  Currently the only
1762 such column is C<items.cn_sort>.
1763
1764 This routine differs from C<_set_derived_columns_for_add>
1765 in that it needs to handle partial item records.  In other
1766 words, the caller of C<ModItem> may have supplied only one
1767 or two columns to be changed, so this function needs to
1768 determine whether any of the columns to be changed affect
1769 any of the derived columns.  Also, if a derived column
1770 depends on more than one column, but the caller is not
1771 changing all of then, this routine retrieves the unchanged
1772 values from the database in order to ensure a correct
1773 calculation.
1774
1775 =cut
1776
1777 sub _set_derived_columns_for_mod {
1778     my $item = shift;
1779
1780     foreach my $column (keys %derived_columns) {
1781         my $builder = $derived_columns{$column}->{'BUILDER'};
1782         my $source_values = {};
1783         my %missing_sources = ();
1784         my $must_recalc = 0;
1785         foreach my $source_column (keys %{ $derived_columns{$column} }) {
1786             next if $source_column eq 'BUILDER';
1787             if (exists $item->{$source_column}) {
1788                 $must_recalc = 1;
1789                 $source_values->{$source_column} = $item->{$source_column};
1790             } else {
1791                 $missing_sources{$source_column} = 1;
1792             }
1793         }
1794         if ($must_recalc) {
1795             foreach my $source_column (keys %missing_sources) {
1796                 $source_values->{$source_column} = _get_single_item_column($source_column, $item->{'itemnumber'});
1797             }
1798             $builder->($item, $source_values);
1799         }
1800     }
1801 }
1802
1803 =head2 _do_column_fixes_for_mod
1804
1805   _do_column_fixes_for_mod($item);
1806
1807 Given an item hashref containing one or more
1808 columns to modify, fix up certain values.
1809 Specifically, set to 0 any passed value
1810 of C<notforloan>, C<damaged>, C<itemlost>, or
1811 C<wthdrawn> that is either undefined or
1812 contains the empty string.
1813
1814 =cut
1815
1816 sub _do_column_fixes_for_mod {
1817     my $item = shift;
1818
1819     if (exists $item->{'notforloan'} and
1820         (not defined $item->{'notforloan'} or $item->{'notforloan'} eq '')) {
1821         $item->{'notforloan'} = 0;
1822     }
1823     if (exists $item->{'damaged'} and
1824         (not defined $item->{'damaged'} or $item->{'damaged'} eq '')) {
1825         $item->{'damaged'} = 0;
1826     }
1827     if (exists $item->{'itemlost'} and
1828         (not defined $item->{'itemlost'} or $item->{'itemlost'} eq '')) {
1829         $item->{'itemlost'} = 0;
1830     }
1831     if (exists $item->{'wthdrawn'} and
1832         (not defined $item->{'wthdrawn'} or $item->{'wthdrawn'} eq '')) {
1833         $item->{'wthdrawn'} = 0;
1834     }
1835     if (exists $item->{'location'} && !exists $item->{'permanent_location'}) {
1836         $item->{'permanent_location'} = $item->{'location'};
1837     }
1838     if (exists $item->{'timestamp'}) {
1839         delete $item->{'timestamp'};
1840     }
1841 }
1842
1843 =head2 _get_single_item_column
1844
1845   _get_single_item_column($column, $itemnumber);
1846
1847 Retrieves the value of a single column from an C<items>
1848 row specified by C<$itemnumber>.
1849
1850 =cut
1851
1852 sub _get_single_item_column {
1853     my $column = shift;
1854     my $itemnumber = shift;
1855
1856     my $dbh = C4::Context->dbh;
1857     my $sth = $dbh->prepare("SELECT $column FROM items WHERE itemnumber = ?");
1858     $sth->execute($itemnumber);
1859     my ($value) = $sth->fetchrow();
1860     return $value;
1861 }
1862
1863 =head2 _calc_items_cn_sort
1864
1865   _calc_items_cn_sort($item, $source_values);
1866
1867 Helper routine to calculate C<items.cn_sort>.
1868
1869 =cut
1870
1871 sub _calc_items_cn_sort {
1872     my $item = shift;
1873     my $source_values = shift;
1874
1875     $item->{'items.cn_sort'} = GetClassSort($source_values->{'items.cn_source'}, $source_values->{'itemcallnumber'}, "");
1876 }
1877
1878 =head2 _set_defaults_for_add
1879
1880   _set_defaults_for_add($item_hash);
1881
1882 Given an item hash representing an item to be added, set
1883 correct default values for columns whose default value
1884 is not handled by the DBMS.  This includes the following
1885 columns:
1886
1887 =over 2
1888
1889 =item *
1890
1891 C<items.dateaccessioned>
1892
1893 =item *
1894
1895 C<items.notforloan>
1896
1897 =item *
1898
1899 C<items.damaged>
1900
1901 =item *
1902
1903 C<items.itemlost>
1904
1905 =item *
1906
1907 C<items.wthdrawn>
1908
1909 =back
1910
1911 =cut
1912
1913 sub _set_defaults_for_add {
1914     my $item = shift;
1915     $item->{dateaccessioned} ||= C4::Dates->new->output('iso');
1916     $item->{$_} ||= 0 for (qw( notforloan damaged itemlost wthdrawn));
1917 }
1918
1919 =head2 _koha_new_item
1920
1921   my ($itemnumber,$error) = _koha_new_item( $item, $barcode );
1922
1923 Perform the actual insert into the C<items> table.
1924
1925 =cut
1926
1927 sub _koha_new_item {
1928     my ( $item, $barcode ) = @_;
1929     my $dbh=C4::Context->dbh;
1930     my $error;
1931     my $query =
1932            "INSERT INTO items SET
1933             biblionumber        = ?,
1934             biblioitemnumber    = ?,
1935             barcode             = ?,
1936             dateaccessioned     = ?,
1937             booksellerid        = ?,
1938             homebranch          = ?,
1939             price               = ?,
1940             replacementprice    = ?,
1941             replacementpricedate = NOW(),
1942             datelastborrowed    = ?,
1943             datelastseen        = NOW(),
1944             stack               = ?,
1945             notforloan          = ?,
1946             damaged             = ?,
1947             itemlost            = ?,
1948             wthdrawn            = ?,
1949             itemcallnumber      = ?,
1950             restricted          = ?,
1951             itemnotes           = ?,
1952             holdingbranch       = ?,
1953             paidfor             = ?,
1954             location            = ?,
1955             onloan              = ?,
1956             issues              = ?,
1957             renewals            = ?,
1958             reserves            = ?,
1959             cn_source           = ?,
1960             cn_sort             = ?,
1961             ccode               = ?,
1962             itype               = ?,
1963             materials           = ?,
1964             uri = ?,
1965             enumchron           = ?,
1966             more_subfields_xml  = ?,
1967             copynumber          = ?,
1968             stocknumber         = ?
1969           ";
1970     my $sth = $dbh->prepare($query);
1971    $sth->execute(
1972             $item->{'biblionumber'},
1973             $item->{'biblioitemnumber'},
1974             $barcode,
1975             $item->{'dateaccessioned'},
1976             $item->{'booksellerid'},
1977             $item->{'homebranch'},
1978             $item->{'price'},
1979             $item->{'replacementprice'},
1980             $item->{datelastborrowed},
1981             $item->{stack},
1982             $item->{'notforloan'},
1983             $item->{'damaged'},
1984             $item->{'itemlost'},
1985             $item->{'wthdrawn'},
1986             $item->{'itemcallnumber'},
1987             $item->{'restricted'},
1988             $item->{'itemnotes'},
1989             $item->{'holdingbranch'},
1990             $item->{'paidfor'},
1991             $item->{'location'},
1992             $item->{'onloan'},
1993             $item->{'issues'},
1994             $item->{'renewals'},
1995             $item->{'reserves'},
1996             $item->{'items.cn_source'},
1997             $item->{'items.cn_sort'},
1998             $item->{'ccode'},
1999             $item->{'itype'},
2000             $item->{'materials'},
2001             $item->{'uri'},
2002             $item->{'enumchron'},
2003             $item->{'more_subfields_xml'},
2004             $item->{'copynumber'},
2005             $item->{'stocknumber'},
2006     );
2007     my $itemnumber = $dbh->{'mysql_insertid'};
2008     if ( defined $sth->errstr ) {
2009         $error.="ERROR in _koha_new_item $query".$sth->errstr;
2010     }
2011     return ( $itemnumber, $error );
2012 }
2013
2014 =head2 MoveItemFromBiblio
2015
2016   MoveItemFromBiblio($itenumber, $frombiblio, $tobiblio);
2017
2018 Moves an item from a biblio to another
2019
2020 Returns undef if the move failed or the biblionumber of the destination record otherwise
2021
2022 =cut
2023
2024 sub MoveItemFromBiblio {
2025     my ($itemnumber, $frombiblio, $tobiblio) = @_;
2026     my $dbh = C4::Context->dbh;
2027     my $sth = $dbh->prepare("SELECT biblioitemnumber FROM biblioitems WHERE biblionumber = ?");
2028     $sth->execute( $tobiblio );
2029     my ( $tobiblioitem ) = $sth->fetchrow();
2030     $sth = $dbh->prepare("UPDATE items SET biblioitemnumber = ?, biblionumber = ? WHERE itemnumber = ? AND biblionumber = ?");
2031     my $return = $sth->execute($tobiblioitem, $tobiblio, $itemnumber, $frombiblio);
2032     if ($return == 1) {
2033
2034         # Getting framework
2035         my $frameworkcode = GetFrameworkCode($frombiblio);
2036
2037         # Getting marc field for itemnumber
2038         my ($itemtag, $itemsubfield) = GetMarcFromKohaField('items.itemnumber', $frameworkcode);
2039
2040         # Getting the record we want to move the item from
2041         my $record = GetMarcBiblio($frombiblio);
2042
2043         # The item we want to move
2044         my $item;
2045
2046         # For each item
2047         foreach my $fielditem ($record->field($itemtag)){
2048                 # If it is the item we want to move
2049                 if ($fielditem->subfield($itemsubfield) == $itemnumber) {
2050                     # We save it
2051                     $item = $fielditem;
2052                     # Then delete it from the record
2053                     $record->delete_field($fielditem)
2054                 }
2055         }
2056
2057         # If we found an item (should always true, except in case of database-marcxml inconsistency)
2058         if ($item) {
2059
2060             # Checking if the item we want to move is in an order
2061             my $order = GetOrderFromItemnumber($itemnumber);
2062             if ($order) {
2063                 # Replacing the biblionumber within the order if necessary
2064                 $order->{'biblionumber'} = $tobiblio;
2065                 ModOrder($order);
2066             }
2067
2068             # Saving the modification
2069             ModBiblioMarc($record, $frombiblio, $frameworkcode);
2070
2071             # Getting the record we want to move the item to
2072             $record = GetMarcBiblio($tobiblio);
2073
2074             # Inserting the previously saved item
2075             $record->insert_fields_ordered($item);
2076
2077             # Saving the modification
2078             ModBiblioMarc($record, $tobiblio, $frameworkcode);
2079
2080         } else {
2081             return undef;
2082         }
2083     } else {
2084         return undef;
2085     }
2086 }
2087
2088 =head2 DelItemCheck
2089
2090    DelItemCheck($dbh, $biblionumber, $itemnumber);
2091
2092 Exported function (core API) for deleting an item record in Koha if there no current issue.
2093
2094 =cut
2095
2096 sub DelItemCheck {
2097     my ( $dbh, $biblionumber, $itemnumber ) = @_;
2098     my $error;
2099
2100     # check that there is no issue on this item before deletion.
2101     my $sth=$dbh->prepare("select * from issues i where i.itemnumber=?");
2102     $sth->execute($itemnumber);
2103
2104     my $item = GetItem($itemnumber);
2105     my $onloan = $sth->fetchrow;
2106     if ($onloan) {
2107         $error = "book_on_loan";
2108     }
2109     elsif (C4::Context->preference("IndependantBranches") and (C4::Context->userenv->{branch} ne $item->{C4::Context->preference("HomeOrHoldingBranch")||'homebranch'})){
2110         $error = "not_same_branch";
2111     }
2112     else {
2113         if ($onloan){
2114             $error = "book_on_loan"
2115         }
2116         else {
2117             # check it doesnt have a waiting reserve
2118             $sth=$dbh->prepare("SELECT * FROM reserves WHERE (found = 'W' or found = 'T') AND itemnumber = ?");
2119             $sth->execute($itemnumber);
2120             my $reserve=$sth->fetchrow;
2121             if ($reserve) {
2122                 $error = "book_reserved";
2123             }
2124             else {
2125                 DelItem($dbh, $biblionumber, $itemnumber);
2126                 return 1;
2127             }
2128         }
2129     }
2130     return $error;
2131 }
2132
2133 =head2 _koha_modify_item
2134
2135   my ($itemnumber,$error) =_koha_modify_item( $item );
2136
2137 Perform the actual update of the C<items> row.  Note that this
2138 routine accepts a hashref specifying the columns to update.
2139
2140 =cut
2141
2142 sub _koha_modify_item {
2143     my ( $item ) = @_;
2144     my $dbh=C4::Context->dbh;
2145     my $error;
2146
2147     my $query = "UPDATE items SET ";
2148     my @bind;
2149     for my $key ( keys %$item ) {
2150         $query.="$key=?,";
2151         push @bind, $item->{$key};
2152     }
2153     $query =~ s/,$//;
2154     $query .= " WHERE itemnumber=?";
2155     push @bind, $item->{'itemnumber'};
2156     my $sth = C4::Context->dbh->prepare($query);
2157     $sth->execute(@bind);
2158     if ( C4::Context->dbh->errstr ) {
2159         $error.="ERROR in _koha_modify_item $query".$dbh->errstr;
2160         warn $error;
2161     }
2162     return ($item->{'itemnumber'},$error);
2163 }
2164
2165 =head2 _koha_delete_item
2166
2167   _koha_delete_item( $dbh, $itemnum );
2168
2169 Internal function to delete an item record from the koha tables
2170
2171 =cut
2172
2173 sub _koha_delete_item {
2174     my ( $dbh, $itemnum ) = @_;
2175
2176     # save the deleted item to deleteditems table
2177     my $sth = $dbh->prepare("SELECT * FROM items WHERE itemnumber=?");
2178     $sth->execute($itemnum);
2179     my $data = $sth->fetchrow_hashref();
2180     my $query = "INSERT INTO deleteditems SET ";
2181     my @bind  = ();
2182     foreach my $key ( keys %$data ) {
2183         $query .= "$key = ?,";
2184         push( @bind, $data->{$key} );
2185     }
2186     $query =~ s/\,$//;
2187     $sth = $dbh->prepare($query);
2188     $sth->execute(@bind);
2189
2190     # delete from items table
2191     $sth = $dbh->prepare("DELETE FROM items WHERE itemnumber=?");
2192     $sth->execute($itemnum);
2193     return undef;
2194 }
2195
2196 =head2 _marc_from_item_hash
2197
2198   my $item_marc = _marc_from_item_hash($item, $frameworkcode[, $unlinked_item_subfields]);
2199
2200 Given an item hash representing a complete item record,
2201 create a C<MARC::Record> object containing an embedded
2202 tag representing that item.
2203
2204 The third, optional parameter C<$unlinked_item_subfields> is
2205 an arrayref of subfields (not mapped to C<items> fields per the
2206 framework) to be added to the MARC representation
2207 of the item.
2208
2209 =cut
2210
2211 sub _marc_from_item_hash {
2212     my $item = shift;
2213     my $frameworkcode = shift;
2214     my $unlinked_item_subfields;
2215     if (@_) {
2216         $unlinked_item_subfields = shift;
2217     }
2218
2219     # Tack on 'items.' prefix to column names so lookup from MARC frameworks will work
2220     # Also, don't emit a subfield if the underlying field is blank.
2221     my $mungeditem = { map {  (defined($item->{$_}) and $item->{$_} ne '') ?
2222                                 (/^items\./ ? ($_ => $item->{$_}) : ("items.$_" => $item->{$_}))
2223                                 : ()  } keys %{ $item } };
2224
2225     my $item_marc = MARC::Record->new();
2226     foreach my $item_field ( keys %{$mungeditem} ) {
2227         my ( $tag, $subfield ) = GetMarcFromKohaField( $item_field, $frameworkcode );
2228         next unless defined $tag and defined $subfield;    # skip if not mapped to MARC field
2229         my @values = split(/\s?\|\s?/, $mungeditem->{$item_field}, -1);
2230         foreach my $value (@values){
2231             if ( my $field = $item_marc->field($tag) ) {
2232                     $field->add_subfields( $subfield => $value );
2233             } else {
2234                 my $add_subfields = [];
2235                 if (defined $unlinked_item_subfields and ref($unlinked_item_subfields) eq 'ARRAY' and $#$unlinked_item_subfields > -1) {
2236                     $add_subfields = $unlinked_item_subfields;
2237             }
2238             $item_marc->add_fields( $tag, " ", " ", $subfield => $value, @$add_subfields );
2239             }
2240         }
2241     }
2242
2243     return $item_marc;
2244 }
2245
2246 =head2 _add_item_field_to_biblio
2247
2248   _add_item_field_to_biblio($item_marc, $biblionumber, $frameworkcode);
2249
2250 Adds the fields from a MARC record containing the
2251 representation of a Koha item record to the MARC
2252 biblio record.  The input C<$item_marc> record
2253 is expect to contain just one field, the embedded
2254 item information field.
2255
2256 =cut
2257
2258 sub _add_item_field_to_biblio {
2259     my ($item_marc, $biblionumber, $frameworkcode) = @_;
2260
2261     my $biblio_marc = GetMarcBiblio($biblionumber);
2262     foreach my $field ($item_marc->fields()) {
2263         $biblio_marc->append_fields($field);
2264     }
2265
2266     ModBiblioMarc($biblio_marc, $biblionumber, $frameworkcode);
2267 }
2268
2269 =head2 _replace_item_field_in_biblio
2270
2271   &_replace_item_field_in_biblio($item_marc, $biblionumber, $itemnumber, $frameworkcode)
2272
2273 Given a MARC::Record C<$item_marc> containing one tag with the MARC
2274 representation of the item, examine the biblio MARC
2275 for the corresponding tag for that item and
2276 replace it with the tag from C<$item_marc>.
2277
2278 =cut
2279
2280 sub _replace_item_field_in_biblio {
2281     my ($ItemRecord, $biblionumber, $itemnumber, $frameworkcode) = @_;
2282     my $dbh = C4::Context->dbh;
2283
2284     # get complete MARC record & replace the item field by the new one
2285     my $completeRecord = GetMarcBiblio($biblionumber);
2286     my ($itemtag,$itemsubfield) = GetMarcFromKohaField("items.itemnumber",$frameworkcode);
2287     my $itemField = $ItemRecord->field($itemtag);
2288     my @items = $completeRecord->field($itemtag);
2289     my $found = 0;
2290     foreach (@items) {
2291         if ($_->subfield($itemsubfield) eq $itemnumber) {
2292             $_->replace_with($itemField);
2293             $found = 1;
2294         }
2295     }
2296
2297     unless ($found) {
2298         # If we haven't found the matching field,
2299         # just add it.  However, this means that
2300         # there is likely a bug.
2301         $completeRecord->append_fields($itemField);
2302     }
2303
2304     # save the record
2305     ModBiblioMarc($completeRecord, $biblionumber, $frameworkcode);
2306 }
2307
2308 =head2 _repack_item_errors
2309
2310 Add an error message hash generated by C<CheckItemPreSave>
2311 to a list of errors.
2312
2313 =cut
2314
2315 sub _repack_item_errors {
2316     my $item_sequence_num = shift;
2317     my $item_ref = shift;
2318     my $error_ref = shift;
2319
2320     my @repacked_errors = ();
2321
2322     foreach my $error_code (sort keys %{ $error_ref }) {
2323         my $repacked_error = {};
2324         $repacked_error->{'item_sequence'} = $item_sequence_num;
2325         $repacked_error->{'item_barcode'} = exists($item_ref->{'barcode'}) ? $item_ref->{'barcode'} : '';
2326         $repacked_error->{'error_code'} = $error_code;
2327         $repacked_error->{'error_information'} = $error_ref->{$error_code};
2328         push @repacked_errors, $repacked_error;
2329     }
2330
2331     return @repacked_errors;
2332 }
2333
2334 =head2 _get_unlinked_item_subfields
2335
2336   my $unlinked_item_subfields = _get_unlinked_item_subfields($original_item_marc, $frameworkcode);
2337
2338 =cut
2339
2340 sub _get_unlinked_item_subfields {
2341     my $original_item_marc = shift;
2342     my $frameworkcode = shift;
2343
2344     my $marcstructure = GetMarcStructure(1, $frameworkcode);
2345
2346     # assume that this record has only one field, and that that
2347     # field contains only the item information
2348     my $subfields = [];
2349     my @fields = $original_item_marc->fields();
2350     if ($#fields > -1) {
2351         my $field = $fields[0];
2352             my $tag = $field->tag();
2353         foreach my $subfield ($field->subfields()) {
2354             if (defined $subfield->[1] and
2355                 $subfield->[1] ne '' and
2356                 !$marcstructure->{$tag}->{$subfield->[0]}->{'kohafield'}) {
2357                 push @$subfields, $subfield->[0] => $subfield->[1];
2358             }
2359         }
2360     }
2361     return $subfields;
2362 }
2363
2364 =head2 _get_unlinked_subfields_xml
2365
2366   my $unlinked_subfields_xml = _get_unlinked_subfields_xml($unlinked_item_subfields);
2367
2368 =cut
2369
2370 sub _get_unlinked_subfields_xml {
2371     my $unlinked_item_subfields = shift;
2372
2373     my $xml;
2374     if (defined $unlinked_item_subfields and ref($unlinked_item_subfields) eq 'ARRAY' and $#$unlinked_item_subfields > -1) {
2375         my $marc = MARC::Record->new();
2376         # use of tag 999 is arbitrary, and doesn't need to match the item tag
2377         # used in the framework
2378         $marc->append_fields(MARC::Field->new('999', ' ', ' ', @$unlinked_item_subfields));
2379         $marc->encoding("UTF-8");
2380         $xml = $marc->as_xml("USMARC");
2381     }
2382
2383     return $xml;
2384 }
2385
2386 =head2 _parse_unlinked_item_subfields_from_xml
2387
2388   my $unlinked_item_subfields = _parse_unlinked_item_subfields_from_xml($whole_item->{'more_subfields_xml'}):
2389
2390 =cut
2391
2392 sub  _parse_unlinked_item_subfields_from_xml {
2393     my $xml = shift;
2394
2395     return unless defined $xml and $xml ne "";
2396     my $marc = MARC::Record->new_from_xml(StripNonXmlChars($xml),'UTF-8');
2397     my $unlinked_subfields = [];
2398     my @fields = $marc->fields();
2399     if ($#fields > -1) {
2400         foreach my $subfield ($fields[0]->subfields()) {
2401             push @$unlinked_subfields, $subfield->[0] => $subfield->[1];
2402         }
2403     }
2404     return $unlinked_subfields;
2405 }
2406
2407 1;