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
   9 # under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 3 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # Koha is distributed in the hope that it will be useful, but
  14 # WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  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 List::MoreUtils qw/any/;
  33 use YAML qw/Load/;
  34 use DateTime::Format::MySQL;
  35 use Data::Dumper; # used as part of logging item record changes, not just for
  36                   # debugging; so please don't remove this
  37 use Koha::DateUtils qw/dt_from_string/;
  38
  39 use Koha::Database;
  40
  41 use vars qw($VERSION @ISA @EXPORT);
  42
  43 BEGIN {
  44     $VERSION = 3.07.00.049;
  45
  46         require Exporter;
  47     @ISA = qw( Exporter );
  48
  49     # function exports
  50     @EXPORT = qw(
  51         GetItem
  52         AddItemFromMarc
  53         AddItem
  54         AddItemBatchFromMarc
  55         ModItemFromMarc
  56     Item2Marc
  57         ModItem
  58         ModDateLastSeen
  59         ModItemTransfer
  60         DelItem
  61
  62         CheckItemPreSave
  63
  64         GetItemStatus
  65         GetItemLocation
  66         GetLostItems
  67         GetItemsForInventory
  68         GetItemsCount
  69         GetItemInfosOf
  70         GetItemsByBiblioitemnumber
  71         GetItemsInfo
  72         GetItemsLocationInfo
  73         GetHostItemsInfo
  74         GetItemnumbersForBiblio
  75         get_itemnumbers_of
  76         get_hostitemnumbers_of
  77         GetItemnumberFromBarcode
  78         GetBarcodeFromItemnumber
  79         GetHiddenItemnumbers
  80         DelItemCheck
  81     MoveItemFromBiblio
  82     GetLatestAcquisitions
  83
  84         CartToShelf
  85         ShelfToCart
  86
  87         GetAnalyticsCount
  88         GetItemHolds
  89
  90         SearchItemsByField
  91         SearchItems
  92
  93         PrepareItemrecordDisplay
  94
  95     );
  96 }
  97
  98 =head1 NAME
  99
 100 C4::Items - item management functions
 101
 102 =head1 DESCRIPTION
 103
 104 This module contains an API for manipulating item
 105 records in Koha, and is used by cataloguing, circulation,
 106 acquisitions, and serials management.
 107
 108 A Koha item record is stored in two places: the
 109 items table and embedded in a MARC tag in the XML
 110 version of the associated bib record in C<biblioitems.marcxml>.
 111 This is done to allow the item information to be readily
 112 indexed (e.g., by Zebra), but means that each item
 113 modification transaction must keep the items table
 114 and the MARC XML in sync at all times.
 115
 116 Consequently, all code that creates, modifies, or deletes
 117 item records B<must> use an appropriate function from
 118 C<C4::Items>.  If no existing function is suitable, it is
 119 better to add one to C<C4::Items> than to use add
 120 one-off SQL statements to add or modify items.
 121
 122 The items table will be considered authoritative.  In other
 123 words, if there is ever a discrepancy between the items
 124 table and the MARC XML, the items table should be considered
 125 accurate.
 126
 127 =head1 HISTORICAL NOTE
 128
 129 Most of the functions in C<C4::Items> were originally in
 130 the C<C4::Biblio> module.
 131
 132 =head1 CORE EXPORTED FUNCTIONS
 133
 134 The following functions are meant for use by users
 135 of C<C4::Items>
 136
 137 =cut
 138
 139 =head2 GetItem
 140
 141   $item = GetItem($itemnumber,$barcode,$serial);
 142
 143 Return item information, for a given itemnumber or barcode.
 144 The return value is a hashref mapping item column
 145 names to values.  If C<$serial> is true, include serial publication data.
 146
 147 =cut
 148
 149 sub GetItem {
 150     my ($itemnumber,$barcode, $serial) = @_;
 151     my $dbh = C4::Context->dbh;
 152         my $data;
 153
 154     if ($itemnumber) {
 155         my $sth = $dbh->prepare("
 156             SELECT * FROM items
 157             WHERE itemnumber = ?");
 158         $sth->execute($itemnumber);
 159         $data = $sth->fetchrow_hashref;
 160     } else {
 161         my $sth = $dbh->prepare("
 162             SELECT * FROM items
 163             WHERE barcode = ?"
 164             );
 165         $sth->execute($barcode);
 166         $data = $sth->fetchrow_hashref;
 167     }
 168
 169     return unless ( $data );
 170
 171     if ( $serial) {
 172     my $ssth = $dbh->prepare("SELECT serialseq,publisheddate from serialitems left join serial on serialitems.serialid=serial.serialid where serialitems.itemnumber=?");
 173         $ssth->execute($data->{'itemnumber'}) ;
 174         ($data->{'serialseq'} , $data->{'publisheddate'}) = $ssth->fetchrow_array();
 175     }
 176         #if we don't have an items.itype, use biblioitems.itemtype.
 177     # FIXME this should respect the itypes systempreference
 178     # if (C4::Context->preference('item-level_itypes')) {
 179         if( ! $data->{'itype'} ) {
 180                 my $sth = $dbh->prepare("SELECT itemtype FROM biblioitems  WHERE biblionumber = ?");
 181                 $sth->execute($data->{'biblionumber'});
 182                 ($data->{'itype'}) = $sth->fetchrow_array;
 183         }
 184     return $data;
 185 }    # sub GetItem
 186
 187 =head2 CartToShelf
 188
 189   CartToShelf($itemnumber);
 190
 191 Set the current shelving location of the item record
 192 to its stored permanent shelving location.  This is
 193 primarily used to indicate when an item whose current
 194 location is a special processing ('PROC') or shelving cart
 195 ('CART') location is back in the stacks.
 196
 197 =cut
 198
 199 sub CartToShelf {
 200     my ( $itemnumber ) = @_;
 201
 202     unless ( $itemnumber ) {
 203         croak "FAILED CartToShelf() - no itemnumber supplied";
 204     }
 205
 206     my $item = GetItem($itemnumber);
 207     if ( $item->{location} eq 'CART' ) {
 208         $item->{location} = $item->{permanent_location};
 209         ModItem($item, undef, $itemnumber);
 210     }
 211 }
 212
 213 =head2 ShelfToCart
 214
 215   ShelfToCart($itemnumber);
 216
 217 Set the current shelving location of the item
 218 to shelving cart ('CART').
 219
 220 =cut
 221
 222 sub ShelfToCart {
 223     my ( $itemnumber ) = @_;
 224
 225     unless ( $itemnumber ) {
 226         croak "FAILED ShelfToCart() - no itemnumber supplied";
 227     }
 228
 229     my $item = GetItem($itemnumber);
 230     $item->{'location'} = 'CART';
 231     ModItem($item, undef, $itemnumber);
 232 }
 233
 234 =head2 AddItemFromMarc
 235
 236   my ($biblionumber, $biblioitemnumber, $itemnumber)
 237       = AddItemFromMarc($source_item_marc, $biblionumber);
 238
 239 Given a MARC::Record object containing an embedded item
 240 record and a biblionumber, create a new item record.
 241
 242 =cut
 243
 244 sub AddItemFromMarc {
 245     my ( $source_item_marc, $biblionumber ) = @_;
 246     my $dbh = C4::Context->dbh;
 247
 248     # parse item hash from MARC
 249     my $frameworkcode = GetFrameworkCode( $biblionumber );
 250         my ($itemtag,$itemsubfield)=GetMarcFromKohaField("items.itemnumber",$frameworkcode);
 251
 252         my $localitemmarc=MARC::Record->new;
 253         $localitemmarc->append_fields($source_item_marc->field($itemtag));
 254     my $item = &TransformMarcToKoha( $dbh, $localitemmarc, $frameworkcode ,'items');
 255     my $unlinked_item_subfields = _get_unlinked_item_subfields($localitemmarc, $frameworkcode);
 256     return AddItem($item, $biblionumber, $dbh, $frameworkcode, $unlinked_item_subfields);
 257 }
 258
 259 =head2 AddItem
 260
 261   my ($biblionumber, $biblioitemnumber, $itemnumber)
 262       = AddItem($item, $biblionumber[, $dbh, $frameworkcode, $unlinked_item_subfields]);
 263
 264 Given a hash containing item column names as keys,
 265 create a new Koha item record.
 266
 267 The first two optional parameters (C<$dbh> and C<$frameworkcode>)
 268 do not need to be supplied for general use; they exist
 269 simply to allow them to be picked up from AddItemFromMarc.
 270
 271 The final optional parameter, C<$unlinked_item_subfields>, contains
 272 an arrayref containing subfields present in the original MARC
 273 representation of the item (e.g., from the item editor) that are
 274 not mapped to C<items> columns directly but should instead
 275 be stored in C<items.more_subfields_xml> and included in
 276 the biblio items tag for display and indexing.
 277
 278 =cut
 279
 280 sub AddItem {
 281     my $item = shift;
 282     my $biblionumber = shift;
 283
 284     my $dbh           = @_ ? shift : C4::Context->dbh;
 285     my $frameworkcode = @_ ? shift : GetFrameworkCode( $biblionumber );
 286     my $unlinked_item_subfields;
 287     if (@_) {
 288         $unlinked_item_subfields = shift
 289     };
 290
 291     # needs old biblionumber and biblioitemnumber
 292     $item->{'biblionumber'} = $biblionumber;
 293     my $sth = $dbh->prepare("SELECT biblioitemnumber FROM biblioitems WHERE biblionumber=?");
 294     $sth->execute( $item->{'biblionumber'} );
 295     ($item->{'biblioitemnumber'}) = $sth->fetchrow;
 296
 297     _set_defaults_for_add($item);
 298     _set_derived_columns_for_add($item);
 299     $item->{'more_subfields_xml'} = _get_unlinked_subfields_xml($unlinked_item_subfields);
 300     # FIXME - checks here
 301     unless ( $item->{itype} ) {  # default to biblioitem.itemtype if no itype
 302         my $itype_sth = $dbh->prepare("SELECT itemtype FROM biblioitems WHERE biblionumber = ?");
 303         $itype_sth->execute( $item->{'biblionumber'} );
 304         ( $item->{'itype'} ) = $itype_sth->fetchrow_array;
 305     }
 306
 307         my ( $itemnumber, $error ) = _koha_new_item( $item, $item->{barcode} );
 308     $item->{'itemnumber'} = $itemnumber;
 309
 310     ModZebra( $item->{biblionumber}, "specialUpdate", "biblioserver" );
 311
 312     logaction("CATALOGUING", "ADD", $itemnumber, "item") if C4::Context->preference("CataloguingLog");
 313
 314     return ($item->{biblionumber}, $item->{biblioitemnumber}, $itemnumber);
 315 }
 316
 317 =head2 AddItemBatchFromMarc
 318
 319   ($itemnumber_ref, $error_ref) = AddItemBatchFromMarc($record,
 320              $biblionumber, $biblioitemnumber, $frameworkcode);
 321
 322 Efficiently create item records from a MARC biblio record with
 323 embedded item fields.  This routine is suitable for batch jobs.
 324
 325 This API assumes that the bib record has already been
 326 saved to the C<biblio> and C<biblioitems> tables.  It does
 327 not expect that C<biblioitems.marc> and C<biblioitems.marcxml>
 328 are populated, but it will do so via a call to ModBibiloMarc.
 329
 330 The goal of this API is to have a similar effect to using AddBiblio
 331 and AddItems in succession, but without inefficient repeated
 332 parsing of the MARC XML bib record.
 333
 334 This function returns an arrayref of new itemsnumbers and an arrayref of item
 335 errors encountered during the processing.  Each entry in the errors
 336 list is a hashref containing the following keys:
 337
 338 =over
 339
 340 =item item_sequence
 341
 342 Sequence number of original item tag in the MARC record.
 343
 344 =item item_barcode
 345
 346 Item barcode, provide to assist in the construction of
 347 useful error messages.
 348
 349 =item error_code
 350
 351 Code representing the error condition.  Can be 'duplicate_barcode',
 352 'invalid_homebranch', or 'invalid_holdingbranch'.
 353
 354 =item error_information
 355
 356 Additional information appropriate to the error condition.
 357
 358 =back
 359
 360 =cut
 361
 362 sub AddItemBatchFromMarc {
 363     my ($record, $biblionumber, $biblioitemnumber, $frameworkcode) = @_;
 364     my $error;
 365     my @itemnumbers = ();
 366     my @errors = ();
 367     my $dbh = C4::Context->dbh;
 368
 369     # We modify the record, so lets work on a clone so we don't change the
 370     # original.
 371     $record = $record->clone();
 372     # loop through the item tags and start creating items
 373     my @bad_item_fields = ();
 374     my ($itemtag, $itemsubfield) = &GetMarcFromKohaField("items.itemnumber",'');
 375     my $item_sequence_num = 0;
 376     ITEMFIELD: foreach my $item_field ($record->field($itemtag)) {
 377         $item_sequence_num++;
 378         # we take the item field and stick it into a new
 379         # MARC record -- this is required so far because (FIXME)
 380         # TransformMarcToKoha requires a MARC::Record, not a MARC::Field
 381         # and there is no TransformMarcFieldToKoha
 382         my $temp_item_marc = MARC::Record->new();
 383         $temp_item_marc->append_fields($item_field);
 384
 385         # add biblionumber and biblioitemnumber
 386         my $item = TransformMarcToKoha( $dbh, $temp_item_marc, $frameworkcode, 'items' );
 387         my $unlinked_item_subfields = _get_unlinked_item_subfields($temp_item_marc, $frameworkcode);
 388         $item->{'more_subfields_xml'} = _get_unlinked_subfields_xml($unlinked_item_subfields);
 389         $item->{'biblionumber'} = $biblionumber;
 390         $item->{'biblioitemnumber'} = $biblioitemnumber;
 391
 392         # check for duplicate barcode
 393         my %item_errors = CheckItemPreSave($item);
 394         if (%item_errors) {
 395             push @errors, _repack_item_errors($item_sequence_num, $item, \%item_errors);
 396             push @bad_item_fields, $item_field;
 397             next ITEMFIELD;
 398         }
 399
 400         _set_defaults_for_add($item);
 401         _set_derived_columns_for_add($item);
 402         my ( $itemnumber, $error ) = _koha_new_item( $item, $item->{barcode} );
 403         warn $error if $error;
 404         push @itemnumbers, $itemnumber; # FIXME not checking error
 405         $item->{'itemnumber'} = $itemnumber;
 406
 407         logaction("CATALOGUING", "ADD", $itemnumber, "item") if C4::Context->preference("CataloguingLog");
 408
 409         my $new_item_marc = _marc_from_item_hash($item, $frameworkcode, $unlinked_item_subfields);
 410         $item_field->replace_with($new_item_marc->field($itemtag));
 411     }
 412
 413     # remove any MARC item fields for rejected items
 414     foreach my $item_field (@bad_item_fields) {
 415         $record->delete_field($item_field);
 416     }
 417
 418     # update the MARC biblio
 419  #   $biblionumber = ModBiblioMarc( $record, $biblionumber, $frameworkcode );
 420
 421     return (\@itemnumbers, \@errors);
 422 }
 423
 424 =head2 ModItemFromMarc
 425
 426   ModItemFromMarc($item_marc, $biblionumber, $itemnumber);
 427
 428 This function updates an item record based on a supplied
 429 C<MARC::Record> object containing an embedded item field.
 430 This API is meant for the use of C<additem.pl>; for
 431 other purposes, C<ModItem> should be used.
 432
 433 This function uses the hash %default_values_for_mod_from_marc,
 434 which contains default values for item fields to
 435 apply when modifying an item.  This is needed beccause
 436 if an item field's value is cleared, TransformMarcToKoha
 437 does not include the column in the
 438 hash that's passed to ModItem, which without
 439 use of this hash makes it impossible to clear
 440 an item field's value.  See bug 2466.
 441
 442 Note that only columns that can be directly
 443 changed from the cataloging and serials
 444 item editors are included in this hash.
 445
 446 Returns item record
 447
 448 =cut
 449
 450 our %default_values_for_mod_from_marc;
 451
 452 sub _build_default_values_for_mod_marc {
 453     my ($frameworkcode) = @_;
 454     return $default_values_for_mod_from_marc{$frameworkcode}
 455       if exists $default_values_for_mod_from_marc{$frameworkcode};
 456     my $marc_structure = C4::Biblio::GetMarcStructure( 1, $frameworkcode );
 457     my $default_values = {
 458         barcode                  => undef,
 459         booksellerid             => undef,
 460         ccode                    => undef,
 461         'items.cn_source'        => undef,
 462         coded_location_qualifier => undef,
 463         copynumber               => undef,
 464         damaged                  => 0,
 465         enumchron                => undef,
 466         holdingbranch            => undef,
 467         homebranch               => undef,
 468         itemcallnumber           => undef,
 469         itemlost                 => 0,
 470         itemnotes                => undef,
 471         itemnotes_nonpublic      => undef,
 472         itype                    => undef,
 473         location                 => undef,
 474         permanent_location       => undef,
 475         materials                => undef,
 476         notforloan               => 0,
 477         # paidfor => undef, # commented, see bug 12817
 478         price                    => undef,
 479         replacementprice         => undef,
 480         replacementpricedate     => undef,
 481         restricted               => undef,
 482         stack                    => undef,
 483         stocknumber              => undef,
 484         uri                      => undef,
 485         withdrawn                => 0,
 486     };
 487     while ( my ( $field, $default_value ) = each %$default_values ) {
 488         my $kohafield = $field;
 489         $kohafield =~ s|^([^\.]+)$|items.$1|;
 490         $default_values_for_mod_from_marc{$frameworkcode}{$field} =
 491           $default_value
 492           if C4::Koha::IsKohaFieldLinked(
 493             { kohafield => $kohafield, frameworkcode => $frameworkcode } );
 494     }
 495     return $default_values_for_mod_from_marc{$frameworkcode};
 496 }
 497
 498 sub ModItemFromMarc {
 499     my $item_marc = shift;
 500     my $biblionumber = shift;
 501     my $itemnumber = shift;
 502
 503     my $dbh           = C4::Context->dbh;
 504     my $frameworkcode = GetFrameworkCode($biblionumber);
 505     my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField( "items.itemnumber", $frameworkcode );
 506
 507     my $localitemmarc = MARC::Record->new;
 508     $localitemmarc->append_fields( $item_marc->field($itemtag) );
 509     my $item = &TransformMarcToKoha( $dbh, $localitemmarc, $frameworkcode, 'items' );
 510     my $default_values = _build_default_values_for_mod_marc();
 511     foreach my $item_field ( keys %$default_values ) {
 512         $item->{$item_field} = $default_values->{$item_field}
 513           unless exists $item->{$item_field};
 514     }
 515     my $unlinked_item_subfields = _get_unlinked_item_subfields( $localitemmarc, $frameworkcode );
 516
 517     ModItem($item, $biblionumber, $itemnumber, $dbh, $frameworkcode, $unlinked_item_subfields);
 518     return $item;
 519 }
 520
 521 =head2 ModItem
 522
 523   ModItem({ column => $newvalue }, $biblionumber, $itemnumber);
 524
 525 Change one or more columns in an item record and update
 526 the MARC representation of the item.
 527
 528 The first argument is a hashref mapping from item column
 529 names to the new values.  The second and third arguments
 530 are the biblionumber and itemnumber, respectively.
 531
 532 The fourth, optional parameter, C<$unlinked_item_subfields>, contains
 533 an arrayref containing subfields present in the original MARC
 534 representation of the item (e.g., from the item editor) that are
 535 not mapped to C<items> columns directly but should instead
 536 be stored in C<items.more_subfields_xml> and included in
 537 the biblio items tag for display and indexing.
 538
 539 If one of the changed columns is used to calculate
 540 the derived value of a column such as C<items.cn_sort>,
 541 this routine will perform the necessary calculation
 542 and set the value.
 543
 544 =cut
 545
 546 sub ModItem {
 547     my $item = shift;
 548     my $biblionumber = shift;
 549     my $itemnumber = shift;
 550
 551     # if $biblionumber is undefined, get it from the current item
 552     unless (defined $biblionumber) {
 553         $biblionumber = _get_single_item_column('biblionumber', $itemnumber);
 554     }
 555
 556     my $dbh           = @_ ? shift : C4::Context->dbh;
 557     my $frameworkcode = @_ ? shift : GetFrameworkCode( $biblionumber );
 558
 559     my $unlinked_item_subfields;
 560     if (@_) {
 561         $unlinked_item_subfields = shift;
 562         $item->{'more_subfields_xml'} = _get_unlinked_subfields_xml($unlinked_item_subfields);
 563     };
 564
 565     $item->{'itemnumber'} = $itemnumber or return;
 566
 567     my @fields = qw( itemlost withdrawn );
 568
 569     # Only call GetItem if we need to set an "on" date field
 570     if ( $item->{itemlost} || $item->{withdrawn} ) {
 571         my $pre_mod_item = GetItem( $item->{'itemnumber'} );
 572         for my $field (@fields) {
 573             if (    defined( $item->{$field} )
 574                 and not $pre_mod_item->{$field}
 575                 and $item->{$field} )
 576             {
 577                 $item->{ $field . '_on' } =
 578                   DateTime::Format::MySQL->format_datetime( dt_from_string() );
 579             }
 580         }
 581     }
 582
 583     # If the field is defined but empty, we are removing and,
 584     # and thus need to clear out the 'on' field as well
 585     for my $field (@fields) {
 586         if ( defined( $item->{$field} ) && !$item->{$field} ) {
 587             $item->{ $field . '_on' } = undef;
 588         }
 589     }
 590
 591
 592     _set_derived_columns_for_mod($item);
 593     _do_column_fixes_for_mod($item);
 594     # FIXME add checks
 595     # duplicate barcode
 596     # attempt to change itemnumber
 597     # attempt to change biblionumber (if we want
 598     # an API to relink an item to a different bib,
 599     # it should be a separate function)
 600
 601     # update items table
 602     _koha_modify_item($item);
 603
 604     # request that bib be reindexed so that searching on current
 605     # item status is possible
 606     ModZebra( $biblionumber, "specialUpdate", "biblioserver" );
 607
 608     logaction("CATALOGUING", "MODIFY", $itemnumber, "item ".Dumper($item)) if C4::Context->preference("CataloguingLog");
 609 }
 610
 611 =head2 ModItemTransfer
 612
 613   ModItemTransfer($itenumber, $frombranch, $tobranch);
 614
 615 Marks an item as being transferred from one branch
 616 to another.
 617
 618 =cut
 619
 620 sub ModItemTransfer {
 621     my ( $itemnumber, $frombranch, $tobranch ) = @_;
 622
 623     my $dbh = C4::Context->dbh;
 624
 625     # Remove the 'shelving cart' location status if it is being used.
 626     CartToShelf( $itemnumber ) if ( C4::Context->preference("ReturnToShelvingCart") );
 627
 628     #new entry in branchtransfers....
 629     my $sth = $dbh->prepare(
 630         "INSERT INTO branchtransfers (itemnumber, frombranch, datesent, tobranch)
 631         VALUES (?, ?, NOW(), ?)");
 632     $sth->execute($itemnumber, $frombranch, $tobranch);
 633
 634     ModItem({ holdingbranch => $tobranch }, undef, $itemnumber);
 635     ModDateLastSeen($itemnumber);
 636     return;
 637 }
 638
 639 =head2 ModDateLastSeen
 640
 641   ModDateLastSeen($itemnum);
 642
 643 Mark item as seen. Is called when an item is issued, returned or manually marked during inventory/stocktaking.
 644 C<$itemnum> is the item number
 645
 646 =cut
 647
 648 sub ModDateLastSeen {
 649     my ($itemnumber) = @_;
 650
 651     my $today = C4::Dates->new();
 652     ModItem({ itemlost => 0, datelastseen => $today->output("iso") }, undef, $itemnumber);
 653 }
 654
 655 =head2 DelItem
 656
 657   DelItem({ itemnumber => $itemnumber, [ biblionumber => $biblionumber ] } );
 658
 659 Exported function (core API) for deleting an item record in Koha.
 660
 661 =cut
 662
 663 sub DelItem {
 664     my ( $params ) = @_;
 665
 666     my $itemnumber   = $params->{itemnumber};
 667     my $biblionumber = $params->{biblionumber};
 668
 669     unless ($biblionumber) {
 670         $biblionumber = C4::Biblio::GetBiblionumberFromItemnumber($itemnumber);
 671     }
 672
 673     # If there is no biblionumber for the given itemnumber, there is nothing to delete
 674     return 0 unless $biblionumber;
 675
 676     # FIXME check the item has no current issues
 677     my $deleted = _koha_delete_item( $itemnumber );
 678
 679     # get the MARC record
 680     my $record = GetMarcBiblio($biblionumber);
 681     ModZebra( $biblionumber, "specialUpdate", "biblioserver" );
 682
 683     #search item field code
 684     logaction("CATALOGUING", "DELETE", $itemnumber, "item") if C4::Context->preference("CataloguingLog");
 685     return $deleted;
 686 }
 687
 688 =head2 CheckItemPreSave
 689
 690     my $item_ref = TransformMarcToKoha($marc, 'items');
 691     # do stuff
 692     my %errors = CheckItemPreSave($item_ref);
 693     if (exists $errors{'duplicate_barcode'}) {
 694         print "item has duplicate barcode: ", $errors{'duplicate_barcode'}, "\n";
 695     } elsif (exists $errors{'invalid_homebranch'}) {
 696         print "item has invalid home branch: ", $errors{'invalid_homebranch'}, "\n";
 697     } elsif (exists $errors{'invalid_holdingbranch'}) {
 698         print "item has invalid holding branch: ", $errors{'invalid_holdingbranch'}, "\n";
 699     } else {
 700         print "item is OK";
 701     }
 702
 703 Given a hashref containing item fields, determine if it can be
 704 inserted or updated in the database.  Specifically, checks for
 705 database integrity issues, and returns a hash containing any
 706 of the following keys, if applicable.
 707
 708 =over 2
 709
 710 =item duplicate_barcode
 711
 712 Barcode, if it duplicates one already found in the database.
 713
 714 =item invalid_homebranch
 715
 716 Home branch, if not defined in branches table.
 717
 718 =item invalid_holdingbranch
 719
 720 Holding branch, if not defined in branches table.
 721
 722 =back
 723
 724 This function does NOT implement any policy-related checks,
 725 e.g., whether current operator is allowed to save an
 726 item that has a given branch code.
 727
 728 =cut
 729
 730 sub CheckItemPreSave {
 731     my $item_ref = shift;
 732     require C4::Branch;
 733
 734     my %errors = ();
 735
 736     # check for duplicate barcode
 737     if (exists $item_ref->{'barcode'} and defined $item_ref->{'barcode'}) {
 738         my $existing_itemnumber = GetItemnumberFromBarcode($item_ref->{'barcode'});
 739         if ($existing_itemnumber) {
 740             if (!exists $item_ref->{'itemnumber'}                       # new item
 741                 or $item_ref->{'itemnumber'} != $existing_itemnumber) { # existing item
 742                 $errors{'duplicate_barcode'} = $item_ref->{'barcode'};
 743             }
 744         }
 745     }
 746
 747     # check for valid home branch
 748     if (exists $item_ref->{'homebranch'} and defined $item_ref->{'homebranch'}) {
 749         my $branch_name = C4::Branch::GetBranchName($item_ref->{'homebranch'});
 750         unless (defined $branch_name) {
 751             # relies on fact that branches.branchname is a non-NULL column,
 752             # so GetBranchName returns undef only if branch does not exist
 753             $errors{'invalid_homebranch'} = $item_ref->{'homebranch'};
 754         }
 755     }
 756
 757     # check for valid holding branch
 758     if (exists $item_ref->{'holdingbranch'} and defined $item_ref->{'holdingbranch'}) {
 759         my $branch_name = C4::Branch::GetBranchName($item_ref->{'holdingbranch'});
 760         unless (defined $branch_name) {
 761             # relies on fact that branches.branchname is a non-NULL column,
 762             # so GetBranchName returns undef only if branch does not exist
 763             $errors{'invalid_holdingbranch'} = $item_ref->{'holdingbranch'};
 764         }
 765     }
 766
 767     return %errors;
 768
 769 }
 770
 771 =head1 EXPORTED SPECIAL ACCESSOR FUNCTIONS
 772
 773 The following functions provide various ways of
 774 getting an item record, a set of item records, or
 775 lists of authorized values for certain item fields.
 776
 777 Some of the functions in this group are candidates
 778 for refactoring -- for example, some of the code
 779 in C<GetItemsByBiblioitemnumber> and C<GetItemsInfo>
 780 has copy-and-paste work.
 781
 782 =cut
 783
 784 =head2 GetItemStatus
 785
 786   $itemstatushash = GetItemStatus($fwkcode);
 787
 788 Returns a list of valid values for the
 789 C<items.notforloan> field.
 790
 791 NOTE: does B<not> return an individual item's
 792 status.
 793
 794 Can be MARC dependant.
 795 fwkcode is optional.
 796 But basically could be can be loan or not
 797 Create a status selector with the following code
 798
 799 =head3 in PERL SCRIPT
 800
 801  my $itemstatushash = getitemstatus;
 802  my @itemstatusloop;
 803  foreach my $thisstatus (keys %$itemstatushash) {
 804      my %row =(value => $thisstatus,
 805                  statusname => $itemstatushash->{$thisstatus}->{'statusname'},
 806              );
 807      push @itemstatusloop, \%row;
 808  }
 809  $template->param(statusloop=>\@itemstatusloop);
 810
 811 =head3 in TEMPLATE
 812
 813 <select name="statusloop" id="statusloop">
 814     <option value="">Default</option>
 815     [% FOREACH statusloo IN statusloop %]
 816         [% IF ( statusloo.selected ) %]
 817             <option value="[% statusloo.value %]" selected="selected">[% statusloo.statusname %]</option>
 818         [% ELSE %]
 819             <option value="[% statusloo.value %]">[% statusloo.statusname %]</option>
 820         [% END %]
 821     [% END %]
 822 </select>
 823
 824 =cut
 825
 826 sub GetItemStatus {
 827
 828     # returns a reference to a hash of references to status...
 829     my ($fwk) = @_;
 830     my %itemstatus;
 831     my $dbh = C4::Context->dbh;
 832     my $sth;
 833     $fwk = '' unless ($fwk);
 834     my ( $tag, $subfield ) =
 835       GetMarcFromKohaField( "items.notforloan", $fwk );
 836     if ( $tag and $subfield ) {
 837         my $sth =
 838           $dbh->prepare(
 839             "SELECT authorised_value
 840             FROM marc_subfield_structure
 841             WHERE tagfield=?
 842                 AND tagsubfield=?
 843                 AND frameworkcode=?
 844             "
 845           );
 846         $sth->execute( $tag, $subfield, $fwk );
 847         if ( my ($authorisedvaluecat) = $sth->fetchrow ) {
 848             my $authvalsth =
 849               $dbh->prepare(
 850                 "SELECT authorised_value,lib
 851                 FROM authorised_values
 852                 WHERE category=?
 853                 ORDER BY lib
 854                 "
 855               );
 856             $authvalsth->execute($authorisedvaluecat);
 857             while ( my ( $authorisedvalue, $lib ) = $authvalsth->fetchrow ) {
 858                 $itemstatus{$authorisedvalue} = $lib;
 859             }
 860             return \%itemstatus;
 861             exit 1;
 862         }
 863         else {
 864
 865             #No authvalue list
 866             # build default
 867         }
 868     }
 869
 870     #No authvalue list
 871     #build default
 872     $itemstatus{"1"} = "Not For Loan";
 873     return \%itemstatus;
 874 }
 875
 876 =head2 GetItemLocation
 877
 878   $itemlochash = GetItemLocation($fwk);
 879
 880 Returns a list of valid values for the
 881 C<items.location> field.
 882
 883 NOTE: does B<not> return an individual item's
 884 location.
 885
 886 where fwk stands for an optional framework code.
 887 Create a location selector with the following code
 888
 889 =head3 in PERL SCRIPT
 890
 891   my $itemlochash = getitemlocation;
 892   my @itemlocloop;
 893   foreach my $thisloc (keys %$itemlochash) {
 894       my $selected = 1 if $thisbranch eq $branch;
 895       my %row =(locval => $thisloc,
 896                   selected => $selected,
 897                   locname => $itemlochash->{$thisloc},
 898                );
 899       push @itemlocloop, \%row;
 900   }
 901   $template->param(itemlocationloop => \@itemlocloop);
 902
 903 =head3 in TEMPLATE
 904
 905   <select name="location">
 906       <option value="">Default</option>
 907   <!-- TMPL_LOOP name="itemlocationloop" -->
 908       <option value="<!-- TMPL_VAR name="locval" -->" <!-- TMPL_IF name="selected" -->selected<!-- /TMPL_IF -->><!-- TMPL_VAR name="locname" --></option>
 909   <!-- /TMPL_LOOP -->
 910   </select>
 911
 912 =cut
 913
 914 sub GetItemLocation {
 915
 916     # returns a reference to a hash of references to location...
 917     my ($fwk) = @_;
 918     my %itemlocation;
 919     my $dbh = C4::Context->dbh;
 920     my $sth;
 921     $fwk = '' unless ($fwk);
 922     my ( $tag, $subfield ) =
 923       GetMarcFromKohaField( "items.location", $fwk );
 924     if ( $tag and $subfield ) {
 925         my $sth =
 926           $dbh->prepare(
 927             "SELECT authorised_value
 928             FROM marc_subfield_structure
 929             WHERE tagfield=?
 930                 AND tagsubfield=?
 931                 AND frameworkcode=?"
 932           );
 933         $sth->execute( $tag, $subfield, $fwk );
 934         if ( my ($authorisedvaluecat) = $sth->fetchrow ) {
 935             my $authvalsth =
 936               $dbh->prepare(
 937                 "SELECT authorised_value,lib
 938                 FROM authorised_values
 939                 WHERE category=?
 940                 ORDER BY lib"
 941               );
 942             $authvalsth->execute($authorisedvaluecat);
 943             while ( my ( $authorisedvalue, $lib ) = $authvalsth->fetchrow ) {
 944                 $itemlocation{$authorisedvalue} = $lib;
 945             }
 946             return \%itemlocation;
 947             exit 1;
 948         }
 949         else {
 950
 951             #No authvalue list
 952             # build default
 953         }
 954     }
 955
 956     #No authvalue list
 957     #build default
 958     $itemlocation{"1"} = "Not For Loan";
 959     return \%itemlocation;
 960 }
 961
 962 =head2 GetLostItems
 963
 964   $items = GetLostItems( $where );
 965
 966 This function gets a list of lost items.
 967
 968 =over 2
 969
 970 =item input:
 971
 972 C<$where> is a hashref. it containts a field of the items table as key
 973 and the value to match as value. For example:
 974
 975 { barcode    => 'abc123',
 976   homebranch => 'CPL',    }
 977
 978 =item return:
 979
 980 C<$items> is a reference to an array full of hashrefs with columns
 981 from the "items" table as keys.
 982
 983 =item usage in the perl script:
 984
 985   my $where = { barcode => '0001548' };
 986   my $items = GetLostItems( $where );
 987   $template->param( itemsloop => $items );
 988
 989 =back
 990
 991 =cut
 992
 993 sub GetLostItems {
 994     # Getting input args.
 995     my $where   = shift;
 996     my $dbh     = C4::Context->dbh;
 997
 998     my $query   = "
 999         SELECT title, author, lib, itemlost, authorised_value, barcode, datelastseen, price, replacementprice, homebranch,
1000                itype, itemtype, holdingbranch, location, itemnotes, items.biblionumber as biblionumber, itemcallnumber
1001         FROM   items
1002             LEFT JOIN biblio ON (items.biblionumber = biblio.biblionumber)
1003             LEFT JOIN biblioitems ON (items.biblionumber = biblioitems.biblionumber)
1004             LEFT JOIN authorised_values ON (items.itemlost = authorised_values.authorised_value)
1005         WHERE
1006                 authorised_values.category = 'LOST'
1007                 AND itemlost IS NOT NULL
1008                 AND itemlost <> 0
1009     ";
1010     my @query_parameters;
1011     foreach my $key (keys %$where) {
1012         $query .= " AND $key LIKE ?";
1013         push @query_parameters, "%$where->{$key}%";
1014     }
1015
1016     my $sth = $dbh->prepare($query);
1017     $sth->execute( @query_parameters );
1018     my $items = [];
1019     while ( my $row = $sth->fetchrow_hashref ){
1020         push @$items, $row;
1021     }
1022     return $items;
1023 }
1024
1025 =head2 GetItemsForInventory
1026
1027 ($itemlist, $iTotalRecords)  = GetItemsForInventory($minlocation, $maxlocation, $location, $itemtype, $ignoreissued, $datelastseen, $branchcode, $offset, $size, $statushash);
1028
1029 Retrieve a list of title/authors/barcode/callnumber, for biblio inventory.
1030
1031 The sub returns a reference to a list of hashes, each containing
1032 itemnumber, author, title, barcode, item callnumber, and date last
1033 seen. It is ordered by callnumber then title.
1034
1035 The required minlocation & maxlocation parameters are used to specify a range of item callnumbers
1036 the datelastseen can be used to specify that you want to see items not seen since a past date only.
1037 offset & size can be used to retrieve only a part of the whole listing (defaut behaviour)
1038 $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.
1039
1040 $iTotalRecords is the number of rows that would have been returned without the $offset, $size limit clause
1041
1042 =cut
1043
1044 sub GetItemsForInventory {
1045     my ( $minlocation, $maxlocation,$location, $itemtype, $ignoreissued, $datelastseen, $branchcode, $branch, $offset, $size, $statushash ) = @_;
1046     my $dbh = C4::Context->dbh;
1047     my ( @bind_params, @where_strings );
1048
1049     my $select_columns = q{
1050         SELECT items.itemnumber, barcode, itemcallnumber, title, author, biblio.biblionumber, biblio.frameworkcode, datelastseen, homebranch, location, notforloan, damaged, itemlost, withdrawn, stocknumber
1051     };
1052     my $select_count = q{SELECT COUNT(*)};
1053     my $query = q{
1054         FROM items
1055         LEFT JOIN biblio ON items.biblionumber = biblio.biblionumber
1056         LEFT JOIN biblioitems on items.biblionumber = biblioitems.biblionumber
1057     };
1058     if ($statushash){
1059         for my $authvfield (keys %$statushash){
1060             if ( scalar @{$statushash->{$authvfield}} > 0 ){
1061                 my $joinedvals = join ',', @{$statushash->{$authvfield}};
1062                 push @where_strings, "$authvfield in (" . $joinedvals . ")";
1063             }
1064         }
1065     }
1066
1067     if ($minlocation) {
1068         push @where_strings, 'itemcallnumber >= ?';
1069         push @bind_params, $minlocation;
1070     }
1071
1072     if ($maxlocation) {
1073         push @where_strings, 'itemcallnumber <= ?';
1074         push @bind_params, $maxlocation;
1075     }
1076
1077     if ($datelastseen) {
1078         $datelastseen = format_date_in_iso($datelastseen);
1079         push @where_strings, '(datelastseen < ? OR datelastseen IS NULL)';
1080         push @bind_params, $datelastseen;
1081     }
1082
1083     if ( $location ) {
1084         push @where_strings, 'items.location = ?';
1085         push @bind_params, $location;
1086     }
1087
1088     if ( $branchcode ) {
1089         if($branch eq "homebranch"){
1090         push @where_strings, 'items.homebranch = ?';
1091         }else{
1092             push @where_strings, 'items.holdingbranch = ?';
1093         }
1094         push @bind_params, $branchcode;
1095     }
1096
1097     if ( $itemtype ) {
1098         push @where_strings, 'biblioitems.itemtype = ?';
1099         push @bind_params, $itemtype;
1100     }
1101
1102     if ( $ignoreissued) {
1103         $query .= "LEFT JOIN issues ON items.itemnumber = issues.itemnumber ";
1104         push @where_strings, 'issues.date_due IS NULL';
1105     }
1106
1107     if ( @where_strings ) {
1108         $query .= 'WHERE ';
1109         $query .= join ' AND ', @where_strings;
1110     }
1111     $query .= ' ORDER BY items.cn_sort, itemcallnumber, title';
1112     my $count_query = $select_count . $query;
1113     $query .= " LIMIT $offset, $size" if ($offset and $size);
1114     $query = $select_columns . $query;
1115     my $sth = $dbh->prepare($query);
1116     $sth->execute( @bind_params );
1117
1118     my @results = ();
1119     my $tmpresults = $sth->fetchall_arrayref({});
1120     $sth = $dbh->prepare( $count_query );
1121     $sth->execute( @bind_params );
1122     my ($iTotalRecords) = $sth->fetchrow_array();
1123
1124     foreach my $row (@$tmpresults) {
1125
1126         # Auth values
1127         foreach (keys %$row) {
1128             # If the koha field is mapped to a marc field
1129             my ($f, $sf) = GetMarcFromKohaField("items.$_", $row->{'frameworkcode'});
1130             if ($f and $sf) {
1131                 # We replace the code with it's description
1132                 my $authvals = C4::Koha::GetKohaAuthorisedValuesFromField($f, $sf, $row->{'frameworkcode'});
1133                 $row->{$_} = $authvals->{$row->{$_}} if defined $authvals->{$row->{$_}};
1134             }
1135         }
1136         push @results, $row;
1137     }
1138
1139     return (\@results, $iTotalRecords);
1140 }
1141
1142 =head2 GetItemsCount
1143
1144   $count = &GetItemsCount( $biblionumber);
1145
1146 This function return count of item with $biblionumber
1147
1148 =cut
1149
1150 sub GetItemsCount {
1151     my ( $biblionumber ) = @_;
1152     my $dbh = C4::Context->dbh;
1153     my $query = "SELECT count(*)
1154           FROM  items
1155           WHERE biblionumber=?";
1156     my $sth = $dbh->prepare($query);
1157     $sth->execute($biblionumber);
1158     my $count = $sth->fetchrow;
1159     return ($count);
1160 }
1161
1162 =head2 GetItemInfosOf
1163
1164   GetItemInfosOf(@itemnumbers);
1165
1166 =cut
1167
1168 sub GetItemInfosOf {
1169     my @itemnumbers = @_;
1170
1171     my $itemnumber_values = @itemnumbers ? join( ',', @itemnumbers ) : "''";
1172
1173     my $query = "
1174         SELECT *
1175         FROM items
1176         WHERE itemnumber IN ($itemnumber_values)
1177     ";
1178     return get_infos_of( $query, 'itemnumber' );
1179 }
1180
1181 =head2 GetItemsByBiblioitemnumber
1182
1183   GetItemsByBiblioitemnumber($biblioitemnumber);
1184
1185 Returns an arrayref of hashrefs suitable for use in a TMPL_LOOP
1186 Called by C<C4::XISBN>
1187
1188 =cut
1189
1190 sub GetItemsByBiblioitemnumber {
1191     my ( $bibitem ) = @_;
1192     my $dbh = C4::Context->dbh;
1193     my $sth = $dbh->prepare("SELECT * FROM items WHERE items.biblioitemnumber = ?") || die $dbh->errstr;
1194     # Get all items attached to a biblioitem
1195     my $i = 0;
1196     my @results;
1197     $sth->execute($bibitem) || die $sth->errstr;
1198     while ( my $data = $sth->fetchrow_hashref ) {
1199         # Foreach item, get circulation information
1200         my $sth2 = $dbh->prepare( "SELECT * FROM issues,borrowers
1201                                    WHERE itemnumber = ?
1202                                    AND issues.borrowernumber = borrowers.borrowernumber"
1203         );
1204         $sth2->execute( $data->{'itemnumber'} );
1205         if ( my $data2 = $sth2->fetchrow_hashref ) {
1206             # if item is out, set the due date and who it is out too
1207             $data->{'date_due'}   = $data2->{'date_due'};
1208             $data->{'cardnumber'} = $data2->{'cardnumber'};
1209             $data->{'borrowernumber'}   = $data2->{'borrowernumber'};
1210         }
1211         else {
1212             # set date_due to blank, so in the template we check itemlost, and withdrawn
1213             $data->{'date_due'} = '';
1214         }    # else
1215         # Find the last 3 people who borrowed this item.
1216         my $query2 = "SELECT * FROM old_issues, borrowers WHERE itemnumber = ?
1217                       AND old_issues.borrowernumber = borrowers.borrowernumber
1218                       ORDER BY returndate desc,timestamp desc LIMIT 3";
1219         $sth2 = $dbh->prepare($query2) || die $dbh->errstr;
1220         $sth2->execute( $data->{'itemnumber'} ) || die $sth2->errstr;
1221         my $i2 = 0;
1222         while ( my $data2 = $sth2->fetchrow_hashref ) {
1223             $data->{"timestamp$i2"} = $data2->{'timestamp'};
1224             $data->{"card$i2"}      = $data2->{'cardnumber'};
1225             $data->{"borrower$i2"}  = $data2->{'borrowernumber'};
1226             $i2++;
1227         }
1228         push(@results,$data);
1229     }
1230     return (\@results);
1231 }
1232
1233 =head2 GetItemsInfo
1234
1235   @results = GetItemsInfo($biblionumber);
1236
1237 Returns information about items with the given biblionumber.
1238
1239 C<GetItemsInfo> returns a list of references-to-hash. Each element
1240 contains a number of keys. Most of them are attributes from the
1241 C<biblio>, C<biblioitems>, C<items>, and C<itemtypes> tables in the
1242 Koha database. Other keys include:
1243
1244 =over 2
1245
1246 =item C<$data-E<gt>{branchname}>
1247
1248 The name (not the code) of the branch to which the book belongs.
1249
1250 =item C<$data-E<gt>{datelastseen}>
1251
1252 This is simply C<items.datelastseen>, except that while the date is
1253 stored in YYYY-MM-DD format in the database, here it is converted to
1254 DD/MM/YYYY format. A NULL date is returned as C<//>.
1255
1256 =item C<$data-E<gt>{datedue}>
1257
1258 =item C<$data-E<gt>{class}>
1259
1260 This is the concatenation of C<biblioitems.classification>, the book's
1261 Dewey code, and C<biblioitems.subclass>.
1262
1263 =item C<$data-E<gt>{ocount}>
1264
1265 I think this is the number of copies of the book available.
1266
1267 =item C<$data-E<gt>{order}>
1268
1269 If this is set, it is set to C<One Order>.
1270
1271 =back
1272
1273 =cut
1274
1275 sub GetItemsInfo {
1276     my ( $biblionumber ) = @_;
1277     my $dbh   = C4::Context->dbh;
1278     # note biblioitems.* must be avoided to prevent large marc and marcxml fields from killing performance.
1279     my $query = "
1280     SELECT items.*,
1281            biblio.*,
1282            biblioitems.volume,
1283            biblioitems.number,
1284            biblioitems.itemtype,
1285            biblioitems.isbn,
1286            biblioitems.issn,
1287            biblioitems.publicationyear,
1288            biblioitems.publishercode,
1289            biblioitems.volumedate,
1290            biblioitems.volumedesc,
1291            biblioitems.lccn,
1292            biblioitems.url,
1293            items.notforloan as itemnotforloan,
1294            issues.borrowernumber,
1295            issues.date_due as datedue,
1296            issues.onsite_checkout,
1297            borrowers.cardnumber,
1298            borrowers.surname,
1299            borrowers.firstname,
1300            borrowers.branchcode as bcode,
1301            serial.serialseq,
1302            serial.publisheddate,
1303            itemtypes.description,
1304            itemtypes.notforloan as notforloan_per_itemtype,
1305            holding.branchurl,
1306            holding.branchname,
1307            holding.opac_info as holding_branch_opac_info,
1308            home.opac_info as home_branch_opac_info
1309     ";
1310     $query .= "
1311      FROM items
1312      LEFT JOIN branches AS holding ON items.holdingbranch = holding.branchcode
1313      LEFT JOIN branches AS home ON items.homebranch=home.branchcode
1314      LEFT JOIN biblio      ON      biblio.biblionumber     = items.biblionumber
1315      LEFT JOIN biblioitems ON biblioitems.biblioitemnumber = items.biblioitemnumber
1316      LEFT JOIN issues USING (itemnumber)
1317      LEFT JOIN borrowers USING (borrowernumber)
1318      LEFT JOIN serialitems USING (itemnumber)
1319      LEFT JOIN serial USING (serialid)
1320      LEFT JOIN itemtypes   ON   itemtypes.itemtype         = "
1321      . (C4::Context->preference('item-level_itypes') ? 'items.itype' : 'biblioitems.itemtype');
1322     $query .= " WHERE items.biblionumber = ? ORDER BY home.branchname, items.enumchron, LPAD( items.copynumber, 8, '0' ), items.dateaccessioned DESC" ;
1323     my $sth = $dbh->prepare($query);
1324     $sth->execute($biblionumber);
1325     my $i = 0;
1326     my @results;
1327     my $serial;
1328
1329     my $userenv = C4::Context->userenv;
1330     my $want_not_same_branch = C4::Context->preference("IndependentBranches") && !C4::Context->IsSuperLibrarian();
1331     while ( my $data = $sth->fetchrow_hashref ) {
1332         if ( $data->{borrowernumber} && $want_not_same_branch) {
1333             $data->{'NOTSAMEBRANCH'} = $data->{'bcode'} ne $userenv->{branch};
1334         }
1335
1336         $serial ||= $data->{'serial'};
1337
1338         # get notforloan complete status if applicable
1339         if ( my $code = C4::Koha::GetAuthValCode( 'items.notforloan', $data->{frameworkcode} ) ) {
1340             $data->{notforloanvalue}     = C4::Koha::GetKohaAuthorisedValueLib( $code, $data->{itemnotforloan} );
1341             $data->{notforloanvalueopac} = C4::Koha::GetKohaAuthorisedValueLib( $code, $data->{itemnotforloan}, 1 );
1342         }
1343
1344         # get restricted status and description if applicable
1345         if ( my $code = C4::Koha::GetAuthValCode( 'items.restricted', $data->{frameworkcode} ) ) {
1346             $data->{restrictedopac} = C4::Koha::GetKohaAuthorisedValueLib( $code, $data->{restricted}, 1 );
1347             $data->{restricted}     = C4::Koha::GetKohaAuthorisedValueLib( $code, $data->{restricted} );
1348         }
1349
1350         # my stack procedures
1351         if ( my $code = C4::Koha::GetAuthValCode( 'items.stack', $data->{frameworkcode} ) ) {
1352             $data->{stack}          = C4::Koha::GetKohaAuthorisedValueLib( $code, $data->{stack} );
1353         }
1354
1355         # Find the last 3 people who borrowed this item.
1356         my $sth2 = $dbh->prepare("SELECT * FROM old_issues,borrowers
1357                                     WHERE itemnumber = ?
1358                                     AND old_issues.borrowernumber = borrowers.borrowernumber
1359                                     ORDER BY returndate DESC
1360                                     LIMIT 3");
1361         $sth2->execute($data->{'itemnumber'});
1362         my $ii = 0;
1363         while (my $data2 = $sth2->fetchrow_hashref()) {
1364             $data->{"timestamp$ii"} = $data2->{'timestamp'} if $data2->{'timestamp'};
1365             $data->{"card$ii"}      = $data2->{'cardnumber'} if $data2->{'cardnumber'};
1366             $data->{"borrower$ii"}  = $data2->{'borrowernumber'} if $data2->{'borrowernumber'};
1367             $ii++;
1368         }
1369
1370         $results[$i] = $data;
1371         $i++;
1372     }
1373
1374     return $serial
1375         ? sort { ($b->{'publisheddate'} || $b->{'enumchron'}) cmp ($a->{'publisheddate'} || $a->{'enumchron'}) } @results
1376         : @results;
1377 }
1378
1379 =head2 GetItemsLocationInfo
1380
1381   my @itemlocinfo = GetItemsLocationInfo($biblionumber);
1382
1383 Returns the branch names, shelving location and itemcallnumber for each item attached to the biblio in question
1384
1385 C<GetItemsInfo> returns a list of references-to-hash. Data returned:
1386
1387 =over 2
1388
1389 =item C<$data-E<gt>{homebranch}>
1390
1391 Branch Name of the item's homebranch
1392
1393 =item C<$data-E<gt>{holdingbranch}>
1394
1395 Branch Name of the item's holdingbranch
1396
1397 =item C<$data-E<gt>{location}>
1398
1399 Item's shelving location code
1400
1401 =item C<$data-E<gt>{location_intranet}>
1402
1403 The intranet description for the Shelving Location as set in authorised_values 'LOC'
1404
1405 =item C<$data-E<gt>{location_opac}>
1406
1407 The OPAC description for the Shelving Location as set in authorised_values 'LOC'.  Falls back to intranet description if no OPAC
1408 description is set.
1409
1410 =item C<$data-E<gt>{itemcallnumber}>
1411
1412 Item's itemcallnumber
1413
1414 =item C<$data-E<gt>{cn_sort}>
1415
1416 Item's call number normalized for sorting
1417
1418 =back
1419
1420 =cut
1421
1422 sub GetItemsLocationInfo {
1423         my $biblionumber = shift;
1424         my @results;
1425
1426         my $dbh = C4::Context->dbh;
1427         my $query = "SELECT a.branchname as homebranch, b.branchname as holdingbranch,
1428                             location, itemcallnumber, cn_sort
1429                      FROM items, branches as a, branches as b
1430                      WHERE homebranch = a.branchcode AND holdingbranch = b.branchcode
1431                      AND biblionumber = ?
1432                      ORDER BY cn_sort ASC";
1433         my $sth = $dbh->prepare($query);
1434         $sth->execute($biblionumber);
1435
1436         while ( my $data = $sth->fetchrow_hashref ) {
1437              $data->{location_intranet} = GetKohaAuthorisedValueLib('LOC', $data->{location});
1438              $data->{location_opac}= GetKohaAuthorisedValueLib('LOC', $data->{location}, 1);
1439              push @results, $data;
1440         }
1441         return @results;
1442 }
1443
1444 =head2 GetHostItemsInfo
1445
1446         $hostiteminfo = GetHostItemsInfo($hostfield);
1447         Returns the iteminfo for items linked to records via a host field
1448
1449 =cut
1450
1451 sub GetHostItemsInfo {
1452         my ($record) = @_;
1453         my @returnitemsInfo;
1454
1455         if (C4::Context->preference('marcflavour') eq 'MARC21' ||
1456         C4::Context->preference('marcflavour') eq 'NORMARC'){
1457             foreach my $hostfield ( $record->field('773') ) {
1458                 my $hostbiblionumber = $hostfield->subfield("0");
1459                 my $linkeditemnumber = $hostfield->subfield("9");
1460                 my @hostitemInfos = GetItemsInfo($hostbiblionumber);
1461                 foreach my $hostitemInfo (@hostitemInfos){
1462                         if ($hostitemInfo->{itemnumber} eq $linkeditemnumber){
1463                                 push (@returnitemsInfo,$hostitemInfo);
1464                                 last;
1465                         }
1466                 }
1467             }
1468         } elsif ( C4::Context->preference('marcflavour') eq 'UNIMARC'){
1469             foreach my $hostfield ( $record->field('461') ) {
1470                 my $hostbiblionumber = $hostfield->subfield("0");
1471                 my $linkeditemnumber = $hostfield->subfield("9");
1472                 my @hostitemInfos = GetItemsInfo($hostbiblionumber);
1473                 foreach my $hostitemInfo (@hostitemInfos){
1474                         if ($hostitemInfo->{itemnumber} eq $linkeditemnumber){
1475                                 push (@returnitemsInfo,$hostitemInfo);
1476                                 last;
1477                         }
1478                 }
1479             }
1480         }
1481         return @returnitemsInfo;
1482 }
1483
1484
1485 =head2 GetLastAcquisitions
1486
1487   my $lastacq = GetLastAcquisitions({'branches' => ('branch1','branch2'),
1488                                     'itemtypes' => ('BK','BD')}, 10);
1489
1490 =cut
1491
1492 sub  GetLastAcquisitions {
1493         my ($data,$max) = @_;
1494
1495         my $itemtype = C4::Context->preference('item-level_itypes') ? 'itype' : 'itemtype';
1496
1497         my $number_of_branches = @{$data->{branches}};
1498         my $number_of_itemtypes   = @{$data->{itemtypes}};
1499
1500
1501         my @where = ('WHERE 1 ');
1502         $number_of_branches and push @where
1503            , 'AND holdingbranch IN ('
1504            , join(',', ('?') x $number_of_branches )
1505            , ')'
1506          ;
1507
1508         $number_of_itemtypes and push @where
1509            , "AND $itemtype IN ("
1510            , join(',', ('?') x $number_of_itemtypes )
1511            , ')'
1512          ;
1513
1514         my $query = "SELECT biblio.biblionumber as biblionumber, title, dateaccessioned
1515                                  FROM items RIGHT JOIN biblio ON (items.biblionumber=biblio.biblionumber)
1516                                     RIGHT JOIN biblioitems ON (items.biblioitemnumber=biblioitems.biblioitemnumber)
1517                                     @where
1518                                     GROUP BY biblio.biblionumber
1519                                     ORDER BY dateaccessioned DESC LIMIT $max";
1520
1521         my $dbh = C4::Context->dbh;
1522         my $sth = $dbh->prepare($query);
1523
1524     $sth->execute((@{$data->{branches}}, @{$data->{itemtypes}}));
1525
1526         my @results;
1527         while( my $row = $sth->fetchrow_hashref){
1528                 push @results, {date => $row->{dateaccessioned}
1529                                                 , biblionumber => $row->{biblionumber}
1530                                                 , title => $row->{title}};
1531         }
1532
1533         return @results;
1534 }
1535
1536 =head2 GetItemnumbersForBiblio
1537
1538   my $itemnumbers = GetItemnumbersForBiblio($biblionumber);
1539
1540 Given a single biblionumber, return an arrayref of all the corresponding itemnumbers
1541
1542 =cut
1543
1544 sub GetItemnumbersForBiblio {
1545     my $biblionumber = shift;
1546     my @items;
1547     my $dbh = C4::Context->dbh;
1548     my $sth = $dbh->prepare("SELECT itemnumber FROM items WHERE biblionumber = ?");
1549     $sth->execute($biblionumber);
1550     while (my $result = $sth->fetchrow_hashref) {
1551         push @items, $result->{'itemnumber'};
1552     }
1553     return \@items;
1554 }
1555
1556 =head2 get_itemnumbers_of
1557
1558   my @itemnumbers_of = get_itemnumbers_of(@biblionumbers);
1559
1560 Given a list of biblionumbers, return the list of corresponding itemnumbers
1561 for each biblionumber.
1562
1563 Return a reference on a hash where keys are biblionumbers and values are
1564 references on array of itemnumbers.
1565
1566 =cut
1567
1568 sub get_itemnumbers_of {
1569     my @biblionumbers = @_;
1570
1571     my $dbh = C4::Context->dbh;
1572
1573     my $query = '
1574         SELECT itemnumber,
1575             biblionumber
1576         FROM items
1577         WHERE biblionumber IN (?' . ( ',?' x scalar @biblionumbers - 1 ) . ')
1578     ';
1579     my $sth = $dbh->prepare($query);
1580     $sth->execute(@biblionumbers);
1581
1582     my %itemnumbers_of;
1583
1584     while ( my ( $itemnumber, $biblionumber ) = $sth->fetchrow_array ) {
1585         push @{ $itemnumbers_of{$biblionumber} }, $itemnumber;
1586     }
1587
1588     return \%itemnumbers_of;
1589 }
1590
1591 =head2 get_hostitemnumbers_of
1592
1593   my @itemnumbers_of = get_hostitemnumbers_of($biblionumber);
1594
1595 Given a biblionumber, return the list of corresponding itemnumbers that are linked to it via host fields
1596
1597 Return a reference on a hash where key is a biblionumber and values are
1598 references on array of itemnumbers.
1599
1600 =cut
1601
1602
1603 sub get_hostitemnumbers_of {
1604         my ($biblionumber) = @_;
1605         my $marcrecord = GetMarcBiblio($biblionumber);
1606         my (@returnhostitemnumbers,$tag, $biblio_s, $item_s);
1607
1608         my $marcflavor = C4::Context->preference('marcflavour');
1609         if ($marcflavor eq 'MARC21' || $marcflavor eq 'NORMARC') {
1610         $tag='773';
1611         $biblio_s='0';
1612         $item_s='9';
1613     } elsif ($marcflavor eq 'UNIMARC') {
1614         $tag='461';
1615         $biblio_s='0';
1616         $item_s='9';
1617     }
1618
1619     foreach my $hostfield ( $marcrecord->field($tag) ) {
1620         my $hostbiblionumber = $hostfield->subfield($biblio_s);
1621         my $linkeditemnumber = $hostfield->subfield($item_s);
1622         my @itemnumbers;
1623         if (my $itemnumbers = get_itemnumbers_of($hostbiblionumber)->{$hostbiblionumber})
1624         {
1625             @itemnumbers = @$itemnumbers;
1626         }
1627         foreach my $itemnumber (@itemnumbers){
1628             if ($itemnumber eq $linkeditemnumber){
1629                 push (@returnhostitemnumbers,$itemnumber);
1630                 last;
1631             }
1632         }
1633     }
1634     return @returnhostitemnumbers;
1635 }
1636
1637
1638 =head2 GetItemnumberFromBarcode
1639
1640   $result = GetItemnumberFromBarcode($barcode);
1641
1642 =cut
1643
1644 sub GetItemnumberFromBarcode {
1645     my ($barcode) = @_;
1646     my $dbh = C4::Context->dbh;
1647
1648     my $rq =
1649       $dbh->prepare("SELECT itemnumber FROM items WHERE items.barcode=?");
1650     $rq->execute($barcode);
1651     my ($result) = $rq->fetchrow;
1652     return ($result);
1653 }
1654
1655 =head2 GetBarcodeFromItemnumber
1656
1657   $result = GetBarcodeFromItemnumber($itemnumber);
1658
1659 =cut
1660
1661 sub GetBarcodeFromItemnumber {
1662     my ($itemnumber) = @_;
1663     my $dbh = C4::Context->dbh;
1664
1665     my $rq =
1666       $dbh->prepare("SELECT barcode FROM items WHERE items.itemnumber=?");
1667     $rq->execute($itemnumber);
1668     my ($result) = $rq->fetchrow;
1669     return ($result);
1670 }
1671
1672 =head2 GetHiddenItemnumbers
1673
1674     my @itemnumbers_to_hide = GetHiddenItemnumbers(@items);
1675
1676 Given a list of items it checks which should be hidden from the OPAC given
1677 the current configuration. Returns a list of itemnumbers corresponding to
1678 those that should be hidden.
1679
1680 =cut
1681
1682 sub GetHiddenItemnumbers {
1683     my (@items) = @_;
1684     my @resultitems;
1685
1686     my $yaml = C4::Context->preference('OpacHiddenItems');
1687     return () if (! $yaml =~ /\S/ );
1688     $yaml = "$yaml\n\n"; # YAML is anal on ending \n. Surplus does not hurt
1689     my $hidingrules;
1690     eval {
1691         $hidingrules = YAML::Load($yaml);
1692     };
1693     if ($@) {
1694         warn "Unable to parse OpacHiddenItems syspref : $@";
1695         return ();
1696     }
1697     my $dbh = C4::Context->dbh;
1698
1699     # For each item
1700     foreach my $item (@items) {
1701
1702         # We check each rule
1703         foreach my $field (keys %$hidingrules) {
1704             my $val;
1705             if (exists $item->{$field}) {
1706                 $val = $item->{$field};
1707             }
1708             else {
1709                 my $query = "SELECT $field from items where itemnumber = ?";
1710                 $val = $dbh->selectrow_array($query, undef, $item->{'itemnumber'});
1711             }
1712             $val = '' unless defined $val;
1713
1714             # If the results matches the values in the yaml file
1715             if (any { $val eq $_ } @{$hidingrules->{$field}}) {
1716
1717                 # We add the itemnumber to the list
1718                 push @resultitems, $item->{'itemnumber'};
1719
1720                 # If at least one rule matched for an item, no need to test the others
1721                 last;
1722             }
1723         }
1724     }
1725     return @resultitems;
1726 }
1727
1728 =head3 get_item_authorised_values
1729
1730 find the types and values for all authorised values assigned to this item.
1731
1732 parameters: itemnumber
1733
1734 returns: a hashref malling the authorised value to the value set for this itemnumber
1735
1736     $authorised_values = {
1737              'CCODE'      => undef,
1738              'DAMAGED'    => '0',
1739              'LOC'        => '3',
1740              'LOST'       => '0'
1741              'NOT_LOAN'   => '0',
1742              'RESTRICTED' => undef,
1743              'STACK'      => undef,
1744              'WITHDRAWN'  => '0',
1745              'branches'   => 'CPL',
1746              'cn_source'  => undef,
1747              'itemtypes'  => 'SER',
1748            };
1749
1750 Notes: see C4::Biblio::get_biblio_authorised_values for a similar method at the biblio level.
1751
1752 =cut
1753
1754 sub get_item_authorised_values {
1755     my $itemnumber = shift;
1756
1757     # assume that these entries in the authorised_value table are item level.
1758     my $query = q(SELECT distinct authorised_value, kohafield
1759                     FROM marc_subfield_structure
1760                     WHERE kohafield like 'item%'
1761                       AND authorised_value != '' );
1762
1763     my $itemlevel_authorised_values = C4::Context->dbh->selectall_hashref( $query, 'authorised_value' );
1764     my $iteminfo = GetItem( $itemnumber );
1765     # warn( Data::Dumper->Dump( [ $itemlevel_authorised_values ], [ 'itemlevel_authorised_values' ] ) );
1766     my $return;
1767     foreach my $this_authorised_value ( keys %$itemlevel_authorised_values ) {
1768         my $field = $itemlevel_authorised_values->{ $this_authorised_value }->{'kohafield'};
1769         $field =~ s/^items\.//;
1770         if ( exists $iteminfo->{ $field } ) {
1771             $return->{ $this_authorised_value } = $iteminfo->{ $field };
1772         }
1773     }
1774     # warn( Data::Dumper->Dump( [ $return ], [ 'return' ] ) );
1775     return $return;
1776 }
1777
1778 =head3 get_authorised_value_images
1779
1780 find a list of icons that are appropriate for display based on the
1781 authorised values for a biblio.
1782
1783 parameters: listref of authorised values, such as comes from
1784 get_item_authorised_values or
1785 from C4::Biblio::get_biblio_authorised_values
1786
1787 returns: listref of hashrefs for each image. Each hashref looks like this:
1788
1789       { imageurl => '/intranet-tmpl/prog/img/itemtypeimg/npl/WEB.gif',
1790         label    => '',
1791         category => '',
1792         value    => '', }
1793
1794 Notes: Currently, I put on the full path to the images on the staff
1795 side. This should either be configurable or not done at all. Since I
1796 have to deal with 'intranet' or 'opac' in
1797 get_biblio_authorised_values, perhaps I should be passing it in.
1798
1799 =cut
1800
1801 sub get_authorised_value_images {
1802     my $authorised_values = shift;
1803
1804     my @imagelist;
1805
1806     my $authorised_value_list = GetAuthorisedValues();
1807     # warn ( Data::Dumper->Dump( [ $authorised_value_list ], [ 'authorised_value_list' ] ) );
1808     foreach my $this_authorised_value ( @$authorised_value_list ) {
1809         if ( exists $authorised_values->{ $this_authorised_value->{'category'} }
1810              && $authorised_values->{ $this_authorised_value->{'category'} } eq $this_authorised_value->{'authorised_value'} ) {
1811             # warn ( Data::Dumper->Dump( [ $this_authorised_value ], [ 'this_authorised_value' ] ) );
1812             if ( defined $this_authorised_value->{'imageurl'} ) {
1813                 push @imagelist, { imageurl => C4::Koha::getitemtypeimagelocation( 'intranet', $this_authorised_value->{'imageurl'} ),
1814                                    label    => $this_authorised_value->{'lib'},
1815                                    category => $this_authorised_value->{'category'},
1816                                    value    => $this_authorised_value->{'authorised_value'}, };
1817             }
1818         }
1819     }
1820
1821     # warn ( Data::Dumper->Dump( [ \@imagelist ], [ 'imagelist' ] ) );
1822     return \@imagelist;
1823
1824 }
1825
1826 =head1 LIMITED USE FUNCTIONS
1827
1828 The following functions, while part of the public API,
1829 are not exported.  This is generally because they are
1830 meant to be used by only one script for a specific
1831 purpose, and should not be used in any other context
1832 without careful thought.
1833
1834 =cut
1835
1836 =head2 GetMarcItem
1837
1838   my $item_marc = GetMarcItem($biblionumber, $itemnumber);
1839
1840 Returns MARC::Record of the item passed in parameter.
1841 This function is meant for use only in C<cataloguing/additem.pl>,
1842 where it is needed to support that script's MARC-like
1843 editor.
1844
1845 =cut
1846
1847 sub GetMarcItem {
1848     my ( $biblionumber, $itemnumber ) = @_;
1849
1850     # GetMarcItem has been revised so that it does the following:
1851     #  1. Gets the item information from the items table.
1852     #  2. Converts it to a MARC field for storage in the bib record.
1853     #
1854     # The previous behavior was:
1855     #  1. Get the bib record.
1856     #  2. Return the MARC tag corresponding to the item record.
1857     #
1858     # The difference is that one treats the items row as authoritative,
1859     # while the other treats the MARC representation as authoritative
1860     # under certain circumstances.
1861
1862     my $itemrecord = GetItem($itemnumber);
1863
1864     # Tack on 'items.' prefix to column names so that TransformKohaToMarc will work.
1865     # Also, don't emit a subfield if the underlying field is blank.
1866
1867
1868     return Item2Marc($itemrecord,$biblionumber);
1869
1870 }
1871 sub Item2Marc {
1872         my ($itemrecord,$biblionumber)=@_;
1873     my $mungeditem = {
1874         map {
1875             defined($itemrecord->{$_}) && $itemrecord->{$_} ne '' ? ("items.$_" => $itemrecord->{$_}) : ()
1876         } keys %{ $itemrecord }
1877     };
1878     my $itemmarc = TransformKohaToMarc($mungeditem);
1879     my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField("items.itemnumber",GetFrameworkCode($biblionumber)||'');
1880
1881     my $unlinked_item_subfields = _parse_unlinked_item_subfields_from_xml($mungeditem->{'items.more_subfields_xml'});
1882     if (defined $unlinked_item_subfields and $#$unlinked_item_subfields > -1) {
1883                 foreach my $field ($itemmarc->field($itemtag)){
1884             $field->add_subfields(@$unlinked_item_subfields);
1885         }
1886     }
1887         return $itemmarc;
1888 }
1889
1890 =head1 PRIVATE FUNCTIONS AND VARIABLES
1891
1892 The following functions are not meant to be called
1893 directly, but are documented in order to explain
1894 the inner workings of C<C4::Items>.
1895
1896 =cut
1897
1898 =head2 %derived_columns
1899
1900 This hash keeps track of item columns that
1901 are strictly derived from other columns in
1902 the item record and are not meant to be set
1903 independently.
1904
1905 Each key in the hash should be the name of a
1906 column (as named by TransformMarcToKoha).  Each
1907 value should be hashref whose keys are the
1908 columns on which the derived column depends.  The
1909 hashref should also contain a 'BUILDER' key
1910 that is a reference to a sub that calculates
1911 the derived value.
1912
1913 =cut
1914
1915 my %derived_columns = (
1916     'items.cn_sort' => {
1917         'itemcallnumber' => 1,
1918         'items.cn_source' => 1,
1919         'BUILDER' => \&_calc_items_cn_sort,
1920     }
1921 );
1922
1923 =head2 _set_derived_columns_for_add
1924
1925   _set_derived_column_for_add($item);
1926
1927 Given an item hash representing a new item to be added,
1928 calculate any derived columns.  Currently the only
1929 such column is C<items.cn_sort>.
1930
1931 =cut
1932
1933 sub _set_derived_columns_for_add {
1934     my $item = shift;
1935
1936     foreach my $column (keys %derived_columns) {
1937         my $builder = $derived_columns{$column}->{'BUILDER'};
1938         my $source_values = {};
1939         foreach my $source_column (keys %{ $derived_columns{$column} }) {
1940             next if $source_column eq 'BUILDER';
1941             $source_values->{$source_column} = $item->{$source_column};
1942         }
1943         $builder->($item, $source_values);
1944     }
1945 }
1946
1947 =head2 _set_derived_columns_for_mod
1948
1949   _set_derived_column_for_mod($item);
1950
1951 Given an item hash representing a new item to be modified.
1952 calculate any derived columns.  Currently the only
1953 such column is C<items.cn_sort>.
1954
1955 This routine differs from C<_set_derived_columns_for_add>
1956 in that it needs to handle partial item records.  In other
1957 words, the caller of C<ModItem> may have supplied only one
1958 or two columns to be changed, so this function needs to
1959 determine whether any of the columns to be changed affect
1960 any of the derived columns.  Also, if a derived column
1961 depends on more than one column, but the caller is not
1962 changing all of then, this routine retrieves the unchanged
1963 values from the database in order to ensure a correct
1964 calculation.
1965
1966 =cut
1967
1968 sub _set_derived_columns_for_mod {
1969     my $item = shift;
1970
1971     foreach my $column (keys %derived_columns) {
1972         my $builder = $derived_columns{$column}->{'BUILDER'};
1973         my $source_values = {};
1974         my %missing_sources = ();
1975         my $must_recalc = 0;
1976         foreach my $source_column (keys %{ $derived_columns{$column} }) {
1977             next if $source_column eq 'BUILDER';
1978             if (exists $item->{$source_column}) {
1979                 $must_recalc = 1;
1980                 $source_values->{$source_column} = $item->{$source_column};
1981             } else {
1982                 $missing_sources{$source_column} = 1;
1983             }
1984         }
1985         if ($must_recalc) {
1986             foreach my $source_column (keys %missing_sources) {
1987                 $source_values->{$source_column} = _get_single_item_column($source_column, $item->{'itemnumber'});
1988             }
1989             $builder->($item, $source_values);
1990         }
1991     }
1992 }
1993
1994 =head2 _do_column_fixes_for_mod
1995
1996   _do_column_fixes_for_mod($item);
1997
1998 Given an item hashref containing one or more
1999 columns to modify, fix up certain values.
2000 Specifically, set to 0 any passed value
2001 of C<notforloan>, C<damaged>, C<itemlost>, or
2002 C<withdrawn> that is either undefined or
2003 contains the empty string.
2004
2005 =cut
2006
2007 sub _do_column_fixes_for_mod {
2008     my $item = shift;
2009
2010     if (exists $item->{'notforloan'} and
2011         (not defined $item->{'notforloan'} or $item->{'notforloan'} eq '')) {
2012         $item->{'notforloan'} = 0;
2013     }
2014     if (exists $item->{'damaged'} and
2015         (not defined $item->{'damaged'} or $item->{'damaged'} eq '')) {
2016         $item->{'damaged'} = 0;
2017     }
2018     if (exists $item->{'itemlost'} and
2019         (not defined $item->{'itemlost'} or $item->{'itemlost'} eq '')) {
2020         $item->{'itemlost'} = 0;
2021     }
2022     if (exists $item->{'withdrawn'} and
2023         (not defined $item->{'withdrawn'} or $item->{'withdrawn'} eq '')) {
2024         $item->{'withdrawn'} = 0;
2025     }
2026     if (exists $item->{'location'} && !$item->{'permanent_location'}) {
2027         $item->{'permanent_location'} = $item->{'location'};
2028     }
2029     if (exists $item->{'timestamp'}) {
2030         delete $item->{'timestamp'};
2031     }
2032 }
2033
2034 =head2 _get_single_item_column
2035
2036   _get_single_item_column($column, $itemnumber);
2037
2038 Retrieves the value of a single column from an C<items>
2039 row specified by C<$itemnumber>.
2040
2041 =cut
2042
2043 sub _get_single_item_column {
2044     my $column = shift;
2045     my $itemnumber = shift;
2046
2047     my $dbh = C4::Context->dbh;
2048     my $sth = $dbh->prepare("SELECT $column FROM items WHERE itemnumber = ?");
2049     $sth->execute($itemnumber);
2050     my ($value) = $sth->fetchrow();
2051     return $value;
2052 }
2053
2054 =head2 _calc_items_cn_sort
2055
2056   _calc_items_cn_sort($item, $source_values);
2057
2058 Helper routine to calculate C<items.cn_sort>.
2059
2060 =cut
2061
2062 sub _calc_items_cn_sort {
2063     my $item = shift;
2064     my $source_values = shift;
2065
2066     $item->{'items.cn_sort'} = GetClassSort($source_values->{'items.cn_source'}, $source_values->{'itemcallnumber'}, "");
2067 }
2068
2069 =head2 _set_defaults_for_add
2070
2071   _set_defaults_for_add($item_hash);
2072
2073 Given an item hash representing an item to be added, set
2074 correct default values for columns whose default value
2075 is not handled by the DBMS.  This includes the following
2076 columns:
2077
2078 =over 2
2079
2080 =item *
2081
2082 C<items.dateaccessioned>
2083
2084 =item *
2085
2086 C<items.notforloan>
2087
2088 =item *
2089
2090 C<items.damaged>
2091
2092 =item *
2093
2094 C<items.itemlost>
2095
2096 =item *
2097
2098 C<items.withdrawn>
2099
2100 =back
2101
2102 =cut
2103
2104 sub _set_defaults_for_add {
2105     my $item = shift;
2106     $item->{dateaccessioned} ||= C4::Dates->new->output('iso');
2107     $item->{$_} ||= 0 for (qw( notforloan damaged itemlost withdrawn));
2108 }
2109
2110 =head2 _koha_new_item
2111
2112   my ($itemnumber,$error) = _koha_new_item( $item, $barcode );
2113
2114 Perform the actual insert into the C<items> table.
2115
2116 =cut
2117
2118 sub _koha_new_item {
2119     my ( $item, $barcode ) = @_;
2120     my $dbh=C4::Context->dbh;
2121     my $error;
2122     my $query =
2123            "INSERT INTO items SET
2124             biblionumber        = ?,
2125             biblioitemnumber    = ?,
2126             barcode             = ?,
2127             dateaccessioned     = ?,
2128             booksellerid        = ?,
2129             homebranch          = ?,
2130             price               = ?,
2131             replacementprice    = ?,
2132             replacementpricedate = ?,
2133             datelastborrowed    = ?,
2134             datelastseen        = ?,
2135             stack               = ?,
2136             notforloan          = ?,
2137             damaged             = ?,
2138             itemlost            = ?,
2139             withdrawn            = ?,
2140             itemcallnumber      = ?,
2141             coded_location_qualifier = ?,
2142             restricted          = ?,
2143             itemnotes           = ?,
2144             itemnotes_nonpublic = ?,
2145             holdingbranch       = ?,
2146             paidfor             = ?,
2147             location            = ?,
2148             permanent_location            = ?,
2149             onloan              = ?,
2150             issues              = ?,
2151             renewals            = ?,
2152             reserves            = ?,
2153             cn_source           = ?,
2154             cn_sort             = ?,
2155             ccode               = ?,
2156             itype               = ?,
2157             materials           = ?,
2158             uri = ?,
2159             enumchron           = ?,
2160             more_subfields_xml  = ?,
2161             copynumber          = ?,
2162             stocknumber         = ?
2163           ";
2164     my $sth = $dbh->prepare($query);
2165     my $today = C4::Dates->today('iso');
2166    $sth->execute(
2167             $item->{'biblionumber'},
2168             $item->{'biblioitemnumber'},
2169             $barcode,
2170             $item->{'dateaccessioned'},
2171             $item->{'booksellerid'},
2172             $item->{'homebranch'},
2173             $item->{'price'},
2174             $item->{'replacementprice'},
2175             $item->{'replacementpricedate'} || $today,
2176             $item->{datelastborrowed},
2177             $item->{datelastseen} || $today,
2178             $item->{stack},
2179             $item->{'notforloan'},
2180             $item->{'damaged'},
2181             $item->{'itemlost'},
2182             $item->{'withdrawn'},
2183             $item->{'itemcallnumber'},
2184             $item->{'coded_location_qualifier'},
2185             $item->{'restricted'},
2186             $item->{'itemnotes'},
2187             $item->{'itemnotes_nonpublic'},
2188             $item->{'holdingbranch'},
2189             $item->{'paidfor'},
2190             $item->{'location'},
2191             $item->{'permanent_location'},
2192             $item->{'onloan'},
2193             $item->{'issues'},
2194             $item->{'renewals'},
2195             $item->{'reserves'},
2196             $item->{'items.cn_source'},
2197             $item->{'items.cn_sort'},
2198             $item->{'ccode'},
2199             $item->{'itype'},
2200             $item->{'materials'},
2201             $item->{'uri'},
2202             $item->{'enumchron'},
2203             $item->{'more_subfields_xml'},
2204             $item->{'copynumber'},
2205             $item->{'stocknumber'},
2206     );
2207
2208     my $itemnumber;
2209     if ( defined $sth->errstr ) {
2210         $error.="ERROR in _koha_new_item $query".$sth->errstr;
2211     }
2212     else {
2213         $itemnumber = $dbh->{'mysql_insertid'};
2214     }
2215
2216     return ( $itemnumber, $error );
2217 }
2218
2219 =head2 MoveItemFromBiblio
2220
2221   MoveItemFromBiblio($itenumber, $frombiblio, $tobiblio);
2222
2223 Moves an item from a biblio to another
2224
2225 Returns undef if the move failed or the biblionumber of the destination record otherwise
2226
2227 =cut
2228
2229 sub MoveItemFromBiblio {
2230     my ($itemnumber, $frombiblio, $tobiblio) = @_;
2231     my $dbh = C4::Context->dbh;
2232     my $sth = $dbh->prepare("SELECT biblioitemnumber FROM biblioitems WHERE biblionumber = ?");
2233     $sth->execute( $tobiblio );
2234     my ( $tobiblioitem ) = $sth->fetchrow();
2235     $sth = $dbh->prepare("UPDATE items SET biblioitemnumber = ?, biblionumber = ? WHERE itemnumber = ? AND biblionumber = ?");
2236     my $return = $sth->execute($tobiblioitem, $tobiblio, $itemnumber, $frombiblio);
2237     if ($return == 1) {
2238         ModZebra( $tobiblio, "specialUpdate", "biblioserver" );
2239         ModZebra( $frombiblio, "specialUpdate", "biblioserver" );
2240             # Checking if the item we want to move is in an order
2241         require C4::Acquisition;
2242         my $order = C4::Acquisition::GetOrderFromItemnumber($itemnumber);
2243             if ($order) {
2244                     # Replacing the biblionumber within the order if necessary
2245                     $order->{'biblionumber'} = $tobiblio;
2246                 C4::Acquisition::ModOrder($order);
2247             }
2248         return $tobiblio;
2249         }
2250     return;
2251 }
2252
2253 =head2 DelItemCheck
2254
2255    DelItemCheck($dbh, $biblionumber, $itemnumber);
2256
2257 Exported function (core API) for deleting an item record in Koha if there no current issue.
2258
2259 =cut
2260
2261 sub DelItemCheck {
2262     my ( $dbh, $biblionumber, $itemnumber ) = @_;
2263     my $error;
2264
2265         my $countanalytics=GetAnalyticsCount($itemnumber);
2266
2267
2268     # check that there is no issue on this item before deletion.
2269     my $sth = $dbh->prepare(q{
2270         SELECT COUNT(*) FROM issues
2271         WHERE itemnumber = ?
2272     });
2273     $sth->execute($itemnumber);
2274     my ($onloan) = $sth->fetchrow;
2275
2276     my $item = GetItem($itemnumber);
2277
2278     if ($onloan){
2279         $error = "book_on_loan"
2280     }
2281     elsif ( !C4::Context->IsSuperLibrarian()
2282         and C4::Context->preference("IndependentBranches")
2283         and ( C4::Context->userenv->{branch} ne $item->{'homebranch'} ) )
2284     {
2285         $error = "not_same_branch";
2286     }
2287         else{
2288         # check it doesnt have a waiting reserve
2289         $sth = $dbh->prepare(q{
2290             SELECT COUNT(*) FROM reserves
2291             WHERE (found = 'W' OR found = 'T')
2292             AND itemnumber = ?
2293         });
2294         $sth->execute($itemnumber);
2295         my ($reserve) = $sth->fetchrow;
2296         if ($reserve){
2297             $error = "book_reserved";
2298         } elsif ($countanalytics > 0){
2299                 $error = "linked_analytics";
2300         } else {
2301             DelItem(
2302                 {
2303                     biblionumber => $biblionumber,
2304                     itemnumber   => $itemnumber
2305                 }
2306             );
2307             return 1;
2308         }
2309     }
2310     return $error;
2311 }
2312
2313 =head2 _koha_modify_item
2314
2315   my ($itemnumber,$error) =_koha_modify_item( $item );
2316
2317 Perform the actual update of the C<items> row.  Note that this
2318 routine accepts a hashref specifying the columns to update.
2319
2320 =cut
2321
2322 sub _koha_modify_item {
2323     my ( $item ) = @_;
2324     my $dbh=C4::Context->dbh;
2325     my $error;
2326
2327     my $query = "UPDATE items SET ";
2328     my @bind;
2329     for my $key ( keys %$item ) {
2330         next if ( $key eq 'itemnumber' );
2331         $query.="$key=?,";
2332         push @bind, $item->{$key};
2333     }
2334     $query =~ s/,$//;
2335     $query .= " WHERE itemnumber=?";
2336     push @bind, $item->{'itemnumber'};
2337     my $sth = $dbh->prepare($query);
2338     $sth->execute(@bind);
2339     if ( $sth->err ) {
2340         $error.="ERROR in _koha_modify_item $query: ".$sth->errstr;
2341         warn $error;
2342     }
2343     return ($item->{'itemnumber'},$error);
2344 }
2345
2346 =head2 _koha_delete_item
2347
2348   _koha_delete_item( $itemnum );
2349
2350 Internal function to delete an item record from the koha tables
2351
2352 =cut
2353
2354 sub _koha_delete_item {
2355     my ( $itemnum ) = @_;
2356
2357     my $dbh = C4::Context->dbh;
2358     # save the deleted item to deleteditems table
2359     my $sth = $dbh->prepare("SELECT * FROM items WHERE itemnumber=?");
2360     $sth->execute($itemnum);
2361     my $data = $sth->fetchrow_hashref();
2362
2363     # There is no item to delete
2364     return 0 unless $data;
2365
2366     my $query = "INSERT INTO deleteditems SET ";
2367     my @bind  = ();
2368     foreach my $key ( keys %$data ) {
2369         next if ( $key eq 'timestamp' ); # timestamp will be set by db
2370         $query .= "$key = ?,";
2371         push( @bind, $data->{$key} );
2372     }
2373     $query =~ s/\,$//;
2374     $sth = $dbh->prepare($query);
2375     $sth->execute(@bind);
2376
2377     # delete from items table
2378     $sth = $dbh->prepare("DELETE FROM items WHERE itemnumber=?");
2379     my $deleted = $sth->execute($itemnum);
2380     return ( $deleted == 1 ) ? 1 : 0;
2381 }
2382
2383 =head2 _marc_from_item_hash
2384
2385   my $item_marc = _marc_from_item_hash($item, $frameworkcode[, $unlinked_item_subfields]);
2386
2387 Given an item hash representing a complete item record,
2388 create a C<MARC::Record> object containing an embedded
2389 tag representing that item.
2390
2391 The third, optional parameter C<$unlinked_item_subfields> is
2392 an arrayref of subfields (not mapped to C<items> fields per the
2393 framework) to be added to the MARC representation
2394 of the item.
2395
2396 =cut
2397
2398 sub _marc_from_item_hash {
2399     my $item = shift;
2400     my $frameworkcode = shift;
2401     my $unlinked_item_subfields;
2402     if (@_) {
2403         $unlinked_item_subfields = shift;
2404     }
2405
2406     # Tack on 'items.' prefix to column names so lookup from MARC frameworks will work
2407     # Also, don't emit a subfield if the underlying field is blank.
2408     my $mungeditem = { map {  (defined($item->{$_}) and $item->{$_} ne '') ?
2409                                 (/^items\./ ? ($_ => $item->{$_}) : ("items.$_" => $item->{$_}))
2410                                 : ()  } keys %{ $item } };
2411
2412     my $item_marc = MARC::Record->new();
2413     foreach my $item_field ( keys %{$mungeditem} ) {
2414         my ( $tag, $subfield ) = GetMarcFromKohaField( $item_field, $frameworkcode );
2415         next unless defined $tag and defined $subfield;    # skip if not mapped to MARC field
2416         my @values = split(/\s?\|\s?/, $mungeditem->{$item_field}, -1);
2417         foreach my $value (@values){
2418             if ( my $field = $item_marc->field($tag) ) {
2419                     $field->add_subfields( $subfield => $value );
2420             } else {
2421                 my $add_subfields = [];
2422                 if (defined $unlinked_item_subfields and ref($unlinked_item_subfields) eq 'ARRAY' and $#$unlinked_item_subfields > -1) {
2423                     $add_subfields = $unlinked_item_subfields;
2424             }
2425             $item_marc->add_fields( $tag, " ", " ", $subfield => $value, @$add_subfields );
2426             }
2427         }
2428     }
2429
2430     return $item_marc;
2431 }
2432
2433 =head2 _repack_item_errors
2434
2435 Add an error message hash generated by C<CheckItemPreSave>
2436 to a list of errors.
2437
2438 =cut
2439
2440 sub _repack_item_errors {
2441     my $item_sequence_num = shift;
2442     my $item_ref = shift;
2443     my $error_ref = shift;
2444
2445     my @repacked_errors = ();
2446
2447     foreach my $error_code (sort keys %{ $error_ref }) {
2448         my $repacked_error = {};
2449         $repacked_error->{'item_sequence'} = $item_sequence_num;
2450         $repacked_error->{'item_barcode'} = exists($item_ref->{'barcode'}) ? $item_ref->{'barcode'} : '';
2451         $repacked_error->{'error_code'} = $error_code;
2452         $repacked_error->{'error_information'} = $error_ref->{$error_code};
2453         push @repacked_errors, $repacked_error;
2454     }
2455
2456     return @repacked_errors;
2457 }
2458
2459 =head2 _get_unlinked_item_subfields
2460
2461   my $unlinked_item_subfields = _get_unlinked_item_subfields($original_item_marc, $frameworkcode);
2462
2463 =cut
2464
2465 sub _get_unlinked_item_subfields {
2466     my $original_item_marc = shift;
2467     my $frameworkcode = shift;
2468
2469     my $marcstructure = GetMarcStructure(1, $frameworkcode);
2470
2471     # assume that this record has only one field, and that that
2472     # field contains only the item information
2473     my $subfields = [];
2474     my @fields = $original_item_marc->fields();
2475     if ($#fields > -1) {
2476         my $field = $fields[0];
2477             my $tag = $field->tag();
2478         foreach my $subfield ($field->subfields()) {
2479             if (defined $subfield->[1] and
2480                 $subfield->[1] ne '' and
2481                 !$marcstructure->{$tag}->{$subfield->[0]}->{'kohafield'}) {
2482                 push @$subfields, $subfield->[0] => $subfield->[1];
2483             }
2484         }
2485     }
2486     return $subfields;
2487 }
2488
2489 =head2 _get_unlinked_subfields_xml
2490
2491   my $unlinked_subfields_xml = _get_unlinked_subfields_xml($unlinked_item_subfields);
2492
2493 =cut
2494
2495 sub _get_unlinked_subfields_xml {
2496     my $unlinked_item_subfields = shift;
2497
2498     my $xml;
2499     if (defined $unlinked_item_subfields and ref($unlinked_item_subfields) eq 'ARRAY' and $#$unlinked_item_subfields > -1) {
2500         my $marc = MARC::Record->new();
2501         # use of tag 999 is arbitrary, and doesn't need to match the item tag
2502         # used in the framework
2503         $marc->append_fields(MARC::Field->new('999', ' ', ' ', @$unlinked_item_subfields));
2504         $marc->encoding("UTF-8");
2505         $xml = $marc->as_xml("USMARC");
2506     }
2507
2508     return $xml;
2509 }
2510
2511 =head2 _parse_unlinked_item_subfields_from_xml
2512
2513   my $unlinked_item_subfields = _parse_unlinked_item_subfields_from_xml($whole_item->{'more_subfields_xml'}):
2514
2515 =cut
2516
2517 sub  _parse_unlinked_item_subfields_from_xml {
2518     my $xml = shift;
2519     require C4::Charset;
2520     return unless defined $xml and $xml ne "";
2521     my $marc = MARC::Record->new_from_xml(C4::Charset::StripNonXmlChars($xml),'UTF-8');
2522     my $unlinked_subfields = [];
2523     my @fields = $marc->fields();
2524     if ($#fields > -1) {
2525         foreach my $subfield ($fields[0]->subfields()) {
2526             push @$unlinked_subfields, $subfield->[0] => $subfield->[1];
2527         }
2528     }
2529     return $unlinked_subfields;
2530 }
2531
2532 =head2 GetAnalyticsCount
2533
2534   $count= &GetAnalyticsCount($itemnumber)
2535
2536 counts Usage of itemnumber in Analytical bibliorecords.
2537
2538 =cut
2539
2540 sub GetAnalyticsCount {
2541     my ($itemnumber) = @_;
2542     require C4::Search;
2543
2544     ### ZOOM search here
2545     my $query;
2546     $query= "hi=".$itemnumber;
2547             my ($err,$res,$result) = C4::Search::SimpleSearch($query,0,10);
2548     return ($result);
2549 }
2550
2551 =head2 GetItemHolds
2552
2553   $holds = &GetItemHolds($biblionumber, $itemnumber);
2554
2555 This function return the count of holds with $biblionumber and $itemnumber
2556
2557 =cut
2558
2559 sub GetItemHolds {
2560     my ($biblionumber, $itemnumber) = @_;
2561     my $holds;
2562     my $dbh            = C4::Context->dbh;
2563     my $query          = "SELECT count(*)
2564         FROM  reserves
2565         WHERE biblionumber=? AND itemnumber=?";
2566     my $sth = $dbh->prepare($query);
2567     $sth->execute($biblionumber, $itemnumber);
2568     $holds = $sth->fetchrow;
2569     return $holds;
2570 }
2571
2572 =head2 SearchItemsByField
2573
2574     my $items = SearchItemsByField($field, $value);
2575
2576 SearchItemsByField will search for items on a specific given field.
2577 For instance you can search all items with a specific stocknumber like this:
2578
2579     my $items = SearchItemsByField('stocknumber', $stocknumber);
2580
2581 =cut
2582
2583 sub SearchItemsByField {
2584     my ($field, $value) = @_;
2585
2586     my $filters = [ {
2587             field => $field,
2588             query => $value,
2589     } ];
2590
2591     my ($results) = SearchItems($filters);
2592     return $results;
2593 }
2594
2595 sub _SearchItems_build_where_fragment {
2596     my ($filter) = @_;
2597
2598     my $dbh = C4::Context->dbh;
2599
2600     my $where_fragment;
2601     if (exists($filter->{conjunction})) {
2602         my (@where_strs, @where_args);
2603         foreach my $f (@{ $filter->{filters} }) {
2604             my $fragment = _SearchItems_build_where_fragment($f);
2605             if ($fragment) {
2606                 push @where_strs, $fragment->{str};
2607                 push @where_args, @{ $fragment->{args} };
2608             }
2609         }
2610         my $where_str = '';
2611         if (@where_strs) {
2612             $where_str = '(' . join (' ' . $filter->{conjunction} . ' ', @where_strs) . ')';
2613             $where_fragment = {
2614                 str => $where_str,
2615                 args => \@where_args,
2616             };
2617         }
2618     } else {
2619         my @columns = Koha::Database->new()->schema()->resultset('Item')->result_source->columns;
2620         push @columns, Koha::Database->new()->schema()->resultset('Biblio')->result_source->columns;
2621         push @columns, Koha::Database->new()->schema()->resultset('Biblioitem')->result_source->columns;
2622         my @operators = qw(= != > < >= <= like);
2623         my $field = $filter->{field};
2624         if ( (0 < grep /^$field$/, @columns) or (substr($field, 0, 5) eq 'marc:') ) {
2625             my $op = $filter->{operator};
2626             my $query = $filter->{query};
2627
2628             if (!$op or (0 == grep /^$op$/, @operators)) {
2629                 $op = '='; # default operator
2630             }
2631
2632             my $column;
2633             if ($field =~ /^marc:(\d{3})(?:\$(\w))?$/) {
2634                 my $marcfield = $1;
2635                 my $marcsubfield = $2;
2636                 my ($kohafield) = $dbh->selectrow_array(q|
2637                     SELECT kohafield FROM marc_subfield_structure
2638                     WHERE tagfield=? AND tagsubfield=? AND frameworkcode=''
2639                 |, undef, $marcfield, $marcsubfield);
2640
2641                 if ($kohafield) {
2642                     $column = $kohafield;
2643                 } else {
2644                     # MARC field is not linked to a DB field so we need to use
2645                     # ExtractValue on biblioitems.marcxml or
2646                     # items.more_subfields_xml, depending on the MARC field.
2647                     my $xpath;
2648                     my $sqlfield;
2649                     my ($itemfield) = GetMarcFromKohaField('items.itemnumber');
2650                     if ($marcfield eq $itemfield) {
2651                         $sqlfield = 'more_subfields_xml';
2652                         $xpath = '//record/datafield/subfield[@code="' . $marcsubfield . '"]';
2653                     } else {
2654                         $sqlfield = 'marcxml';
2655                         if ($marcfield < 10) {
2656                             $xpath = "//record/controlfield[\@tag=\"$marcfield\"]";
2657                         } else {
2658                             $xpath = "//record/datafield[\@tag=\"$marcfield\"]/subfield[\@code=\"$marcsubfield\"]";
2659                         }
2660                     }
2661                     $column = "ExtractValue($sqlfield, '$xpath')";
2662                 }
2663             } else {
2664                 $column = $field;
2665             }
2666
2667             if (ref $query eq 'ARRAY') {
2668                 if ($op eq '=') {
2669                     $op = 'IN';
2670                 } elsif ($op eq '!=') {
2671                     $op = 'NOT IN';
2672                 }
2673                 $where_fragment = {
2674                     str => "$column $op (" . join (',', ('?') x @$query) . ")",
2675                     args => $query,
2676                 };
2677             } else {
2678                 $where_fragment = {
2679                     str => "$column $op ?",
2680                     args => [ $query ],
2681                 };
2682             }
2683         }
2684     }
2685
2686     return $where_fragment;
2687 }
2688
2689 =head2 SearchItems
2690
2691     my ($items, $total) = SearchItems($filter, $params);
2692
2693 Perform a search among items
2694
2695 $filter is a reference to a hash which can be a filter, or a combination of filters.
2696
2697 A filter has the following keys:
2698
2699 =over 2
2700
2701 =item * field: the name of a SQL column in table items
2702
2703 =item * query: the value to search in this column
2704
2705 =item * operator: comparison operator. Can be one of = != > < >= <= like
2706
2707 =back
2708
2709 A combination of filters hash the following keys:
2710
2711 =over 2
2712
2713 =item * conjunction: 'AND' or 'OR'
2714
2715 =item * filters: array ref of filters
2716
2717 =back
2718
2719 $params is a reference to a hash that can contain the following parameters:
2720
2721 =over 2
2722
2723 =item * rows: Number of items to return. 0 returns everything (default: 0)
2724
2725 =item * page: Page to return (return items from (page-1)*rows to (page*rows)-1)
2726                (default: 1)
2727
2728 =item * sortby: A SQL column name in items table to sort on
2729
2730 =item * sortorder: 'ASC' or 'DESC'
2731
2732 =back
2733
2734 =cut
2735
2736 sub SearchItems {
2737     my ($filter, $params) = @_;
2738
2739     $filter //= {};
2740     $params //= {};
2741     return unless ref $filter eq 'HASH';
2742     return unless ref $params eq 'HASH';
2743
2744     # Default parameters
2745     $params->{rows} ||= 0;
2746     $params->{page} ||= 1;
2747     $params->{sortby} ||= 'itemnumber';
2748     $params->{sortorder} ||= 'ASC';
2749
2750     my ($where_str, @where_args);
2751     my $where_fragment = _SearchItems_build_where_fragment($filter);
2752     if ($where_fragment) {
2753         $where_str = $where_fragment->{str};
2754         @where_args = @{ $where_fragment->{args} };
2755     }
2756
2757     my $dbh = C4::Context->dbh;
2758     my $query = q{
2759         SELECT SQL_CALC_FOUND_ROWS items.*
2760         FROM items
2761           LEFT JOIN biblio ON biblio.biblionumber = items.biblionumber
2762           LEFT JOIN biblioitems ON biblioitems.biblioitemnumber = items.biblioitemnumber
2763     };
2764     if (defined $where_str and $where_str ne '') {
2765         $query .= qq{ WHERE $where_str };
2766     }
2767
2768     my @columns = Koha::Database->new()->schema()->resultset('Item')->result_source->columns;
2769     push @columns, Koha::Database->new()->schema()->resultset('Biblio')->result_source->columns;
2770     push @columns, Koha::Database->new()->schema()->resultset('Biblioitem')->result_source->columns;
2771     my $sortby = (0 < grep {$params->{sortby} eq $_} @columns)
2772         ? $params->{sortby} : 'itemnumber';
2773     my $sortorder = (uc($params->{sortorder}) eq 'ASC') ? 'ASC' : 'DESC';
2774     $query .= qq{ ORDER BY $sortby $sortorder };
2775
2776     my $rows = $params->{rows};
2777     my @limit_args;
2778     if ($rows > 0) {
2779         my $offset = $rows * ($params->{page}-1);
2780         $query .= qq { LIMIT ?, ? };
2781         push @limit_args, $offset, $rows;
2782     }
2783
2784     my $sth = $dbh->prepare($query);
2785     my $rv = $sth->execute(@where_args, @limit_args);
2786
2787     return unless ($rv);
2788     my ($total_rows) = $dbh->selectrow_array(q{ SELECT FOUND_ROWS() });
2789
2790     return ($sth->fetchall_arrayref({}), $total_rows);
2791 }
2792
2793
2794 =head1  OTHER FUNCTIONS
2795
2796 =head2 _find_value
2797
2798   ($indicators, $value) = _find_value($tag, $subfield, $record,$encoding);
2799
2800 Find the given $subfield in the given $tag in the given
2801 MARC::Record $record.  If the subfield is found, returns
2802 the (indicators, value) pair; otherwise, (undef, undef) is
2803 returned.
2804
2805 PROPOSITION :
2806 Such a function is used in addbiblio AND additem and serial-edit and maybe could be used in Authorities.
2807 I suggest we export it from this module.
2808
2809 =cut
2810
2811 sub _find_value {
2812     my ( $tagfield, $insubfield, $record, $encoding ) = @_;
2813     my @result;
2814     my $indicator;
2815     if ( $tagfield < 10 ) {
2816         if ( $record->field($tagfield) ) {
2817             push @result, $record->field($tagfield)->data();
2818         } else {
2819             push @result, "";
2820         }
2821     } else {
2822         foreach my $field ( $record->field($tagfield) ) {
2823             my @subfields = $field->subfields();
2824             foreach my $subfield (@subfields) {
2825                 if ( @$subfield[0] eq $insubfield ) {
2826                     push @result, @$subfield[1];
2827                     $indicator = $field->indicator(1) . $field->indicator(2);
2828                 }
2829             }
2830         }
2831     }
2832     return ( $indicator, @result );
2833 }
2834
2835
2836 =head2 PrepareItemrecordDisplay
2837
2838   PrepareItemrecordDisplay($itemrecord,$bibnum,$itemumber,$frameworkcode);
2839
2840 Returns a hash with all the fields for Display a given item data in a template
2841
2842 The $frameworkcode returns the item for the given frameworkcode, ONLY if bibnum is not provided
2843
2844 =cut
2845
2846 sub PrepareItemrecordDisplay {
2847
2848     my ( $bibnum, $itemnum, $defaultvalues, $frameworkcode ) = @_;
2849
2850     my $dbh = C4::Context->dbh;
2851     $frameworkcode = &GetFrameworkCode($bibnum) if $bibnum;
2852     my ( $itemtagfield, $itemtagsubfield ) = &GetMarcFromKohaField( "items.itemnumber", $frameworkcode );
2853     my $tagslib = &GetMarcStructure( 1, $frameworkcode );
2854
2855     # return nothing if we don't have found an existing framework.
2856     return q{} unless $tagslib;
2857     my $itemrecord;
2858     if ($itemnum) {
2859         $itemrecord = C4::Items::GetMarcItem( $bibnum, $itemnum );
2860     }
2861     my @loop_data;
2862
2863     my $branch_limit = C4::Context->userenv ? C4::Context->userenv->{"branch"} : "";
2864     my $query = qq{
2865         SELECT authorised_value,lib FROM authorised_values
2866     };
2867     $query .= qq{
2868         LEFT JOIN authorised_values_branches ON ( id = av_id )
2869     } if $branch_limit;
2870     $query .= qq{
2871         WHERE category = ?
2872     };
2873     $query .= qq{ AND ( branchcode = ? OR branchcode IS NULL )} if $branch_limit;
2874     $query .= qq{ ORDER BY lib};
2875     my $authorised_values_sth = $dbh->prepare( $query );
2876     foreach my $tag ( sort keys %{$tagslib} ) {
2877         my $previous_tag = '';
2878         if ( $tag ne '' ) {
2879
2880             # loop through each subfield
2881             my $cntsubf;
2882             foreach my $subfield ( sort keys %{ $tagslib->{$tag} } ) {
2883                 next if ( subfield_is_koha_internal_p($subfield) );
2884                 next if ( $tagslib->{$tag}->{$subfield}->{'tab'} ne "10" );
2885                 my %subfield_data;
2886                 $subfield_data{tag}           = $tag;
2887                 $subfield_data{subfield}      = $subfield;
2888                 $subfield_data{countsubfield} = $cntsubf++;
2889                 $subfield_data{kohafield}     = $tagslib->{$tag}->{$subfield}->{'kohafield'};
2890                 $subfield_data{id}            = "tag_".$tag."_subfield_".$subfield."_".int(rand(1000000));
2891
2892                 #        $subfield_data{marc_lib}=$tagslib->{$tag}->{$subfield}->{lib};
2893                 $subfield_data{marc_lib}   = $tagslib->{$tag}->{$subfield}->{lib};
2894                 $subfield_data{mandatory}  = $tagslib->{$tag}->{$subfield}->{mandatory};
2895                 $subfield_data{repeatable} = $tagslib->{$tag}->{$subfield}->{repeatable};
2896                 $subfield_data{hidden}     = "display:none"
2897                   if ( ( $tagslib->{$tag}->{$subfield}->{hidden} > 4 )
2898                     || ( $tagslib->{$tag}->{$subfield}->{hidden} < -4 ) );
2899                 my ( $x, $defaultvalue );
2900                 if ($itemrecord) {
2901                     ( $x, $defaultvalue ) = _find_value( $tag, $subfield, $itemrecord );
2902                 }
2903                 $defaultvalue = $tagslib->{$tag}->{$subfield}->{defaultvalue} unless $defaultvalue;
2904                 if ( !defined $defaultvalue ) {
2905                     $defaultvalue = q||;
2906                 } else {
2907                     $defaultvalue =~ s/"/&quot;/g;
2908                 }
2909
2910                 # search for itemcallnumber if applicable
2911                 if ( $tagslib->{$tag}->{$subfield}->{kohafield} eq 'items.itemcallnumber'
2912                     && C4::Context->preference('itemcallnumber') ) {
2913                     my $CNtag      = substr( C4::Context->preference('itemcallnumber'), 0, 3 );
2914                     my $CNsubfield = substr( C4::Context->preference('itemcallnumber'), 3, 1 );
2915                     if ( $itemrecord and my $field = $itemrecord->field($CNtag) ) {
2916                         $defaultvalue = $field->subfield($CNsubfield);
2917                     }
2918                 }
2919                 if (   $tagslib->{$tag}->{$subfield}->{kohafield} eq 'items.itemcallnumber'
2920                     && $defaultvalues
2921                     && $defaultvalues->{'callnumber'} ) {
2922                     if( $itemrecord and $defaultvalues and not $itemrecord->field($subfield) ){
2923                         # if the item record exists, only use default value if the item has no callnumber
2924                         $defaultvalue = $defaultvalues->{callnumber};
2925                     } elsif ( !$itemrecord and $defaultvalues ) {
2926                         # if the item record *doesn't* exists, always use the default value
2927                         $defaultvalue = $defaultvalues->{callnumber};
2928                     }
2929                 }
2930                 if (   ( $tagslib->{$tag}->{$subfield}->{kohafield} eq 'items.holdingbranch' || $tagslib->{$tag}->{$subfield}->{kohafield} eq 'items.homebranch' )
2931                     && $defaultvalues
2932                     && $defaultvalues->{'branchcode'} ) {
2933                     if ( $itemrecord and $defaultvalues and not $itemrecord->field($subfield) ) {
2934                         $defaultvalue = $defaultvalues->{branchcode};
2935                     }
2936                 }
2937                 if (   ( $tagslib->{$tag}->{$subfield}->{kohafield} eq 'items.location' )
2938                     && $defaultvalues
2939                     && $defaultvalues->{'location'} ) {
2940
2941                     if ( $itemrecord and $defaultvalues and not $itemrecord->field($subfield) ) {
2942                         # if the item record exists, only use default value if the item has no locationr
2943                         $defaultvalue = $defaultvalues->{location};
2944                     } elsif ( !$itemrecord and $defaultvalues ) {
2945                         # if the item record *doesn't* exists, always use the default value
2946                         $defaultvalue = $defaultvalues->{location};
2947                     }
2948                 }
2949                 if ( $tagslib->{$tag}->{$subfield}->{authorised_value} ) {
2950                     my @authorised_values;
2951                     my %authorised_lib;
2952
2953                     # builds list, depending on authorised value...
2954                     #---- branch
2955                     if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "branches" ) {
2956                         if (   ( C4::Context->preference("IndependentBranches") )
2957                             && !C4::Context->IsSuperLibrarian() ) {
2958                             my $sth = $dbh->prepare( "SELECT branchcode,branchname FROM branches WHERE branchcode = ? ORDER BY branchname" );
2959                             $sth->execute( C4::Context->userenv->{branch} );
2960                             push @authorised_values, ""
2961                               unless ( $tagslib->{$tag}->{$subfield}->{mandatory} );
2962                             while ( my ( $branchcode, $branchname ) = $sth->fetchrow_array ) {
2963                                 push @authorised_values, $branchcode;
2964                                 $authorised_lib{$branchcode} = $branchname;
2965                             }
2966                         } else {
2967                             my $sth = $dbh->prepare( "SELECT branchcode,branchname FROM branches ORDER BY branchname" );
2968                             $sth->execute;
2969                             push @authorised_values, ""
2970                               unless ( $tagslib->{$tag}->{$subfield}->{mandatory} );
2971                             while ( my ( $branchcode, $branchname ) = $sth->fetchrow_array ) {
2972                                 push @authorised_values, $branchcode;
2973                                 $authorised_lib{$branchcode} = $branchname;
2974                             }
2975                         }
2976
2977                         $defaultvalue = C4::Context->userenv ? C4::Context->userenv->{branch} : undef;
2978                         if ( $defaultvalues and $defaultvalues->{branchcode} ) {
2979                             $defaultvalue = $defaultvalues->{branchcode};
2980                         }
2981
2982                         #----- itemtypes
2983                     } elsif ( $tagslib->{$tag}->{$subfield}->{authorised_value} eq "itemtypes" ) {
2984                         my $sth = $dbh->prepare( "SELECT itemtype,description FROM itemtypes ORDER BY description" );
2985                         $sth->execute;
2986                         push @authorised_values, ""
2987                           unless ( $tagslib->{$tag}->{$subfield}->{mandatory} );
2988                         while ( my ( $itemtype, $description ) = $sth->fetchrow_array ) {
2989                             push @authorised_values, $itemtype;
2990                             $authorised_lib{$itemtype} = $description;
2991                         }
2992                         #---- class_sources
2993                     } elsif ( $tagslib->{$tag}->{$subfield}->{authorised_value} eq "cn_source" ) {
2994                         push @authorised_values, "" unless ( $tagslib->{$tag}->{$subfield}->{mandatory} );
2995
2996                         my $class_sources = GetClassSources();
2997                         my $default_source = C4::Context->preference("DefaultClassificationSource");
2998
2999                         foreach my $class_source (sort keys %$class_sources) {
3000                             next unless $class_sources->{$class_source}->{'used'} or
3001                                         ($class_source eq $default_source);
3002                             push @authorised_values, $class_source;
3003                             $authorised_lib{$class_source} = $class_sources->{$class_source}->{'description'};
3004                         }
3005
3006                         $defaultvalue = $default_source;
3007
3008                         #---- "true" authorised value
3009                     } else {
3010                         $authorised_values_sth->execute(
3011                             $tagslib->{$tag}->{$subfield}->{authorised_value},
3012                             $branch_limit ? $branch_limit : ()
3013                         );
3014                         push @authorised_values, ""
3015                           unless ( $tagslib->{$tag}->{$subfield}->{mandatory} );
3016                         while ( my ( $value, $lib ) = $authorised_values_sth->fetchrow_array ) {
3017                             push @authorised_values, $value;
3018                             $authorised_lib{$value} = $lib;
3019                         }
3020                     }
3021                     $subfield_data{marc_value} = {
3022                         type    => 'select',
3023                         values  => \@authorised_values,
3024                         default => "$defaultvalue",
3025                         labels  => \%authorised_lib,
3026                     };
3027                 } elsif ( $tagslib->{$tag}->{$subfield}->{value_builder} ) {
3028                 # it is a plugin
3029                     require Koha::FrameworkPlugin;
3030                     my $plugin = Koha::FrameworkPlugin->new({
3031                         name => $tagslib->{$tag}->{$subfield}->{value_builder},
3032                         item_style => 1,
3033                     });
3034                     my $pars = { dbh => $dbh, record => undef, tagslib =>$tagslib, id => $subfield_data{id}, tabloop => undef };
3035                     $plugin->build( $pars );
3036                     if( !$plugin->errstr ) {
3037                         #TODO Move html to template; see report 12176/13397
3038                         my $tab= $plugin->noclick? '-1': '';
3039                         my $class= $plugin->noclick? ' disabled': '';
3040                         my $title= $plugin->noclick? 'No popup': 'Tag editor';
3041                         $subfield_data{marc_value} = qq[<input type="text" id="$subfield_data{id}" name="field_value" class="input_marceditor" size="50" maxlength="255" /><a href="#" id="buttonDot_$subfield_data{id}" tabindex="$tab" class="buttonDot $class" title="$title">...</a>\n].$plugin->javascript;
3042                     } else {
3043                         warn $plugin->errstr;
3044                         $subfield_data{marc_value} = qq(<input type="text" id="$subfield_data{id}" name="field_value" class="input_marceditor" size="50" maxlength="255" />); # supply default input form
3045                     }
3046                 }
3047                 elsif ( $tag eq '' ) {       # it's an hidden field
3048                     $subfield_data{marc_value} = qq(<input type="hidden" tabindex="1" id="$subfield_data{id}" name="field_value" class="input_marceditor" size="50" maxlength="255" value="$defaultvalue" />);
3049                 }
3050                 elsif ( $tagslib->{$tag}->{$subfield}->{'hidden'} ) {   # FIXME: shouldn't input type be "hidden" ?
3051                     $subfield_data{marc_value} = qq(<input type="text" tabindex="1" id="$subfield_data{id}" name="field_value" class="input_marceditor" size="50" maxlength="255" value="$defaultvalue" />);
3052                 }
3053                 elsif ( length($defaultvalue) > 100
3054                             or (C4::Context->preference("marcflavour") eq "UNIMARC" and
3055                                   300 <= $tag && $tag < 400 && $subfield eq 'a' )
3056                             or (C4::Context->preference("marcflavour") eq "MARC21"  and
3057                                   500 <= $tag && $tag < 600                     )
3058                           ) {
3059                     # oversize field (textarea)
3060                     $subfield_data{marc_value} = qq(<textarea tabindex="1" id="$subfield_data{id}" name="field_value" class="input_marceditor" size="50" maxlength="255">$defaultvalue</textarea>\n");
3061                 } else {
3062                     $subfield_data{marc_value} = "<input type=\"text\" name=\"field_value\" value=\"$defaultvalue\" size=\"50\" maxlength=\"255\" />";
3063                 }
3064                 push( @loop_data, \%subfield_data );
3065             }
3066         }
3067     }
3068     my $itemnumber;
3069     if ( $itemrecord && $itemrecord->field($itemtagfield) ) {
3070         $itemnumber = $itemrecord->subfield( $itemtagfield, $itemtagsubfield );
3071     }
3072     return {
3073         'itemtagfield'    => $itemtagfield,
3074         'itemtagsubfield' => $itemtagsubfield,
3075         'itemnumber'      => $itemnumber,
3076         'iteminformation' => \@loop_data
3077     };
3078 }
3079
3080 1;