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