C4/Items.pm

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