C4/Items.pm

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