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