Koha/Item.pm

   1 package Koha::Item;
   2
   3 # Copyright ByWater Solutions 2014
   4 #
   5 # This file is part of Koha.
   6 #
   7 # Koha is free software; you can redistribute it and/or modify it
   8 # under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # Koha is distributed in the hope that it will be useful, but
  13 # WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  19
  20 use Modern::Perl;
  21
  22 use List::MoreUtils qw( any );
  23 use Try::Tiny qw( catch try );
  24
  25 use Koha::Database;
  26 use Koha::DateUtils qw( dt_from_string output_pref );
  27
  28 use C4::Context;
  29 use C4::Circulation qw( barcodedecode GetBranchItemRule );
  30 use C4::Reserves;
  31 use C4::ClassSource qw( GetClassSort );
  32 use C4::Log qw( logaction );
  33
  34 use Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue;
  35 use Koha::Biblio::ItemGroups;
  36 use Koha::Checkouts;
  37 use Koha::CirculationRules;
  38 use Koha::CoverImages;
  39 use Koha::Exceptions;
  40 use Koha::Exceptions::Checkin;
  41 use Koha::Exceptions::Item::Bundle;
  42 use Koha::Exceptions::Item::Transfer;
  43 use Koha::Item::Attributes;
  44 use Koha::Exceptions::Item::Bundle;
  45 use Koha::Item::Transfer::Limits;
  46 use Koha::Item::Transfers;
  47 use Koha::ItemTypes;
  48 use Koha::Libraries;
  49 use Koha::Patrons;
  50 use Koha::Plugins;
  51 use Koha::Recalls;
  52 use Koha::Result::Boolean;
  53 use Koha::SearchEngine::Indexer;
  54 use Koha::StockRotationItem;
  55 use Koha::StockRotationRotas;
  56 use Koha::TrackedLinks;
  57
  58 use base qw(Koha::Object);
  59
  60 =head1 NAME
  61
  62 Koha::Item - Koha Item object class
  63
  64 =head1 API
  65
  66 =head2 Class methods
  67
  68 =cut
  69
  70 =head3 store
  71
  72     $item->store;
  73
  74 $params can take an optional 'skip_record_index' parameter.
  75 If set, the reindexation process will not happen (index_records not called)
  76 You should not turn it on if you do not understand what it is doing exactly.
  77
  78 =cut
  79
  80 sub store {
  81     my $self = shift;
  82     my $params = @_ ? shift : {};
  83
  84     my $log_action = $params->{log_action} // 1;
  85
  86     # We do not want to oblige callers to pass this value
  87     # Dev conveniences vs performance?
  88     unless ( $self->biblioitemnumber ) {
  89         $self->biblioitemnumber( $self->biblio->biblioitem->biblioitemnumber );
  90     }
  91
  92     # See related changes from C4::Items::AddItem
  93     unless ( $self->itype ) {
  94         $self->itype($self->biblio->biblioitem->itemtype);
  95     }
  96
  97     $self->barcode( C4::Circulation::barcodedecode( $self->barcode ) );
  98
  99     my $today  = dt_from_string;
 100     my $action = 'create';
 101
 102     unless ( $self->in_storage ) { #AddItem
 103
 104         unless ( $self->permanent_location ) {
 105             $self->permanent_location($self->location);
 106         }
 107
 108         my $default_location = C4::Context->preference('NewItemsDefaultLocation');
 109         unless ( $self->location || !$default_location ) {
 110             $self->permanent_location( $self->location || $default_location )
 111               unless $self->permanent_location;
 112             $self->location($default_location);
 113         }
 114
 115         unless ( $self->replacementpricedate ) {
 116             $self->replacementpricedate($today);
 117         }
 118         unless ( $self->datelastseen ) {
 119             $self->datelastseen($today);
 120         }
 121
 122         unless ( $self->dateaccessioned ) {
 123             $self->dateaccessioned($today);
 124         }
 125
 126         if (   $self->itemcallnumber
 127             or $self->cn_source )
 128         {
 129             my $cn_sort = GetClassSort( $self->cn_source, $self->itemcallnumber, "" );
 130             $self->cn_sort($cn_sort);
 131         }
 132
 133     } else { # ModItem
 134
 135         $action = 'modify';
 136
 137         my %updated_columns = $self->_result->get_dirty_columns;
 138         return $self->SUPER::store unless %updated_columns;
 139
 140         # Retrieve the item for comparison if we need to
 141         my $pre_mod_item = (
 142                  exists $updated_columns{itemlost}
 143               or exists $updated_columns{withdrawn}
 144               or exists $updated_columns{damaged}
 145         ) ? $self->get_from_storage : undef;
 146
 147         # Update *_on  fields if needed
 148         # FIXME: Why not for AddItem as well?
 149         my @fields = qw( itemlost withdrawn damaged );
 150         for my $field (@fields) {
 151
 152             # If the field is defined but empty or 0, we are
 153             # removing/unsetting and thus need to clear out
 154             # the 'on' field
 155             if (   exists $updated_columns{$field}
 156                 && defined( $self->$field )
 157                 && !$self->$field )
 158             {
 159                 my $field_on = "${field}_on";
 160                 $self->$field_on(undef);
 161             }
 162             # If the field has changed otherwise, we much update
 163             # the 'on' field
 164             elsif (exists $updated_columns{$field}
 165                 && $updated_columns{$field}
 166                 && !$pre_mod_item->$field )
 167             {
 168                 my $field_on = "${field}_on";
 169                 $self->$field_on(dt_from_string);
 170             }
 171         }
 172
 173         if (   exists $updated_columns{itemcallnumber}
 174             or exists $updated_columns{cn_source} )
 175         {
 176             my $cn_sort = GetClassSort( $self->cn_source, $self->itemcallnumber, "" );
 177             $self->cn_sort($cn_sort);
 178         }
 179
 180
 181         if (    exists $updated_columns{location}
 182             and ( !defined($self->location) or $self->location !~ /^(CART|PROC)$/ )
 183             and not exists $updated_columns{permanent_location} )
 184         {
 185             $self->permanent_location( $self->location );
 186         }
 187
 188         # If item was lost and has now been found,
 189         # reverse any list item charges if necessary.
 190         if (    exists $updated_columns{itemlost}
 191             and $updated_columns{itemlost} <= 0
 192             and $pre_mod_item->itemlost > 0 )
 193         {
 194             $self->_set_found_trigger($pre_mod_item);
 195         }
 196
 197     }
 198
 199     my $result = $self->SUPER::store;
 200     if ( $log_action && C4::Context->preference("CataloguingLog") ) {
 201         $action eq 'create'
 202           ? logaction( "CATALOGUING", "ADD", $self->itemnumber, "item" )
 203           : logaction( "CATALOGUING", "MODIFY", $self->itemnumber, $self );
 204     }
 205     my $indexer = Koha::SearchEngine::Indexer->new({ index => $Koha::SearchEngine::BIBLIOS_INDEX });
 206     $indexer->index_records( $self->biblionumber, "specialUpdate", "biblioserver" )
 207         unless $params->{skip_record_index};
 208     $self->get_from_storage->_after_item_action_hooks({ action => $action });
 209
 210     Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue->new->enqueue(
 211         {
 212             biblio_ids => [ $self->biblionumber ]
 213         }
 214     ) unless $params->{skip_holds_queue} or !C4::Context->preference('RealTimeHoldsQueue');
 215
 216     return $result;
 217 }
 218
 219 =head3 delete
 220
 221 =cut
 222
 223 sub delete {
 224     my $self = shift;
 225     my $params = @_ ? shift : {};
 226
 227     # FIXME check the item has no current issues
 228     # i.e. raise the appropriate exception
 229
 230     # Get the item group so we can delete it later if it has no items left
 231     my $item_group = C4::Context->preference('EnableItemGroups') ? $self->item_group : undef;
 232
 233     my $result = $self->SUPER::delete;
 234
 235     # Delete the item group if it has no items left
 236     $item_group->delete if ( $item_group && $item_group->items->count == 0 );
 237
 238     my $indexer = Koha::SearchEngine::Indexer->new({ index => $Koha::SearchEngine::BIBLIOS_INDEX });
 239     $indexer->index_records( $self->biblionumber, "specialUpdate", "biblioserver" )
 240         unless $params->{skip_record_index};
 241
 242     $self->_after_item_action_hooks({ action => 'delete' });
 243
 244     logaction( "CATALOGUING", "DELETE", $self->itemnumber, "item" )
 245       if C4::Context->preference("CataloguingLog");
 246
 247     Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue->new->enqueue(
 248         {
 249             biblio_ids => [ $self->biblionumber ]
 250         }
 251     ) unless $params->{skip_holds_queue} or !C4::Context->preference('RealTimeHoldsQueue');
 252
 253     return $result;
 254 }
 255
 256 =head3 safe_delete
 257
 258 =cut
 259
 260 sub safe_delete {
 261     my $self = shift;
 262     my $params = @_ ? shift : {};
 263
 264     my $safe_to_delete = $self->safe_to_delete;
 265     return $safe_to_delete unless $safe_to_delete;
 266
 267     $self->move_to_deleted;
 268
 269     return $self->delete($params);
 270 }
 271
 272 =head3 safe_to_delete
 273
 274 returns 1 if the item is safe to delete,
 275
 276 "book_on_loan" if the item is checked out,
 277
 278 "not_same_branch" if the item is blocked by independent branches,
 279
 280 "book_reserved" if the there are holds aganst the item, or
 281
 282 "linked_analytics" if the item has linked analytic records.
 283
 284 "last_item_for_hold" if the item is the last one on a record on which a biblio-level hold is placed
 285
 286 =cut
 287
 288 sub safe_to_delete {
 289     my ($self) = @_;
 290
 291     my $error;
 292
 293     $error = "book_on_loan" if $self->checkout;
 294
 295     $error //= "not_same_branch"
 296       if defined C4::Context->userenv
 297       and defined C4::Context->userenv->{number}
 298       and !Koha::Patrons->find( C4::Context->userenv->{number} )->can_edit_items_from( $self->homebranch );
 299
 300     # check it doesn't have a waiting reserve
 301     $error //= "book_reserved"
 302       if $self->holds->filter_by_found->count;
 303
 304     $error //= "linked_analytics"
 305       if C4::Items::GetAnalyticsCount( $self->itemnumber ) > 0;
 306
 307     $error //= "last_item_for_hold"
 308       if $self->biblio->items->count == 1
 309       && $self->biblio->holds->search(
 310           {
 311               itemnumber => undef,
 312           }
 313         )->count;
 314
 315     if ( $error ) {
 316         return Koha::Result::Boolean->new(0)->add_message({ message => $error });
 317     }
 318
 319     return Koha::Result::Boolean->new(1);
 320 }
 321
 322 =head3 move_to_deleted
 323
 324 my $is_moved = $item->move_to_deleted;
 325
 326 Move an item to the deleteditems table.
 327 This can be done before deleting an item, to make sure the data are not completely deleted.
 328
 329 =cut
 330
 331 sub move_to_deleted {
 332     my ($self) = @_;
 333     my $item_infos = $self->unblessed;
 334     delete $item_infos->{timestamp}; #This ensures the timestamp date in deleteditems will be set to the current timestamp
 335     $item_infos->{deleted_on} = dt_from_string;
 336     return Koha::Database->new->schema->resultset('Deleteditem')->create($item_infos);
 337 }
 338
 339 =head3 effective_itemtype
 340
 341 Returns the itemtype for the item based on whether item level itemtypes are set or not.
 342
 343 =cut
 344
 345 sub effective_itemtype {
 346     my ( $self ) = @_;
 347
 348     return $self->_result()->effective_itemtype();
 349 }
 350
 351 =head3 home_branch
 352
 353 =cut
 354
 355 sub home_branch {
 356     my ($self) = @_;
 357
 358     my $hb_rs = $self->_result->homebranch;
 359
 360     return Koha::Library->_new_from_dbic( $hb_rs );
 361 }
 362
 363 =head3 holding_branch
 364
 365 =cut
 366
 367 sub holding_branch {
 368     my ($self) = @_;
 369
 370     my $hb_rs = $self->_result->holdingbranch;
 371
 372     return Koha::Library->_new_from_dbic( $hb_rs );
 373 }
 374
 375 =head3 biblio
 376
 377 my $biblio = $item->biblio;
 378
 379 Return the bibliographic record of this item
 380
 381 =cut
 382
 383 sub biblio {
 384     my ( $self ) = @_;
 385     my $biblio_rs = $self->_result->biblio;
 386     return Koha::Biblio->_new_from_dbic( $biblio_rs );
 387 }
 388
 389 =head3 biblioitem
 390
 391 my $biblioitem = $item->biblioitem;
 392
 393 Return the biblioitem record of this item
 394
 395 =cut
 396
 397 sub biblioitem {
 398     my ( $self ) = @_;
 399     my $biblioitem_rs = $self->_result->biblioitem;
 400     return Koha::Biblioitem->_new_from_dbic( $biblioitem_rs );
 401 }
 402
 403 =head3 checkout
 404
 405 my $checkout = $item->checkout;
 406
 407 Return the checkout for this item
 408
 409 =cut
 410
 411 sub checkout {
 412     my ( $self ) = @_;
 413     my $checkout_rs = $self->_result->issue;
 414     return unless $checkout_rs;
 415     return Koha::Checkout->_new_from_dbic( $checkout_rs );
 416 }
 417
 418 =head3 item_group
 419
 420 my $item_group = $item->item_group;
 421
 422 Return the item group for this item
 423
 424 =cut
 425
 426 sub item_group {
 427     my ( $self ) = @_;
 428
 429     my $item_group_item = $self->_result->item_group_item;
 430     return unless $item_group_item;
 431
 432     my $item_group_rs = $item_group_item->item_group;
 433     return unless $item_group_rs;
 434
 435     my $item_group = Koha::Biblio::ItemGroup->_new_from_dbic( $item_group_rs );
 436     return $item_group;
 437 }
 438
 439 =head3 return_claims
 440
 441   my $return_claims = $item->return_claims;
 442
 443 Return any return_claims associated with this item
 444
 445 =cut
 446
 447 sub return_claims {
 448     my ( $self, $params, $attrs ) = @_;
 449     my $claims_rs = $self->_result->return_claims->search($params, $attrs);
 450     return Koha::Checkouts::ReturnClaims->_new_from_dbic( $claims_rs );
 451 }
 452
 453 =head3 return_claim
 454
 455   my $return_claim = $item->return_claim;
 456
 457 Returns the most recent unresolved return_claims associated with this item
 458
 459 =cut
 460
 461 sub return_claim {
 462     my ($self) = @_;
 463     my $claims_rs =
 464       $self->_result->return_claims->search( { resolution => undef },
 465         { order_by => { '-desc' => 'created_on' }, rows => 1 } )->single;
 466     return unless $claims_rs;
 467     return Koha::Checkouts::ReturnClaim->_new_from_dbic($claims_rs);
 468 }
 469
 470 =head3 holds
 471
 472 my $holds = $item->holds();
 473 my $holds = $item->holds($params);
 474 my $holds = $item->holds({ found => 'W'});
 475
 476 Return holds attached to an item, optionally accept a hashref of params to pass to search
 477
 478 =cut
 479
 480 sub holds {
 481     my ( $self,$params ) = @_;
 482     my $holds_rs = $self->_result->reserves->search($params);
 483     return Koha::Holds->_new_from_dbic( $holds_rs );
 484 }
 485
 486 =head3 request_transfer
 487
 488   my $transfer = $item->request_transfer(
 489     {
 490         to     => $to_library,
 491         reason => $reason,
 492         [ ignore_limits => 0, enqueue => 1, replace => 1 ]
 493     }
 494   );
 495
 496 Add a transfer request for this item to the given branch for the given reason.
 497
 498 An exception will be thrown if the BranchTransferLimits would prevent the requested
 499 transfer, unless 'ignore_limits' is passed to override the limits.
 500
 501 An exception will be thrown if an active transfer (i.e pending arrival date) is found;
 502 The caller should catch such cases and retry the transfer request as appropriate passing
 503 an appropriate override.
 504
 505 Overrides
 506 * enqueue - Used to queue up the transfer when the existing transfer is found to be in transit.
 507 * replace - Used to replace the existing transfer request with your own.
 508
 509 =cut
 510
 511 sub request_transfer {
 512     my ( $self, $params ) = @_;
 513
 514     # check for mandatory params
 515     my @mandatory = ( 'to', 'reason' );
 516     for my $param (@mandatory) {
 517         unless ( defined( $params->{$param} ) ) {
 518             Koha::Exceptions::MissingParameter->throw(
 519                 error => "The $param parameter is mandatory" );
 520         }
 521     }
 522
 523     Koha::Exceptions::Item::Transfer::Limit->throw()
 524       unless ( $params->{ignore_limits}
 525         || $self->can_be_transferred( { to => $params->{to} } ) );
 526
 527     my $request = $self->get_transfer;
 528     Koha::Exceptions::Item::Transfer::InQueue->throw( transfer => $request )
 529       if ( $request && !$params->{enqueue} && !$params->{replace} );
 530
 531     $request->cancel( { reason => $params->{reason}, force => 1 } )
 532       if ( defined($request) && $params->{replace} );
 533
 534     my $transfer = Koha::Item::Transfer->new(
 535         {
 536             itemnumber    => $self->itemnumber,
 537             daterequested => dt_from_string,
 538             frombranch    => $self->holdingbranch,
 539             tobranch      => $params->{to}->branchcode,
 540             reason        => $params->{reason},
 541             comments      => $params->{comment}
 542         }
 543     )->store();
 544
 545     return $transfer;
 546 }
 547
 548 =head3 get_transfer
 549
 550   my $transfer = $item->get_transfer;
 551
 552 Return the active transfer request or undef
 553
 554 Note: Transfers are retrieved in a Modified FIFO (First In First Out) order
 555 whereby the most recently sent, but not received, transfer will be returned
 556 if it exists, otherwise the oldest unsatisfied transfer will be returned.
 557
 558 This allows for transfers to queue, which is the case for stock rotation and
 559 rotating collections where a manual transfer may need to take precedence but
 560 we still expect the item to end up at a final location eventually.
 561
 562 =cut
 563
 564 sub get_transfer {
 565     my ($self) = @_;
 566
 567     my $transfer = $self->_result->current_branchtransfers->next;
 568     return  Koha::Item::Transfer->_new_from_dbic($transfer) if $transfer;
 569 }
 570
 571 =head3 get_transfers
 572
 573   my $transfer = $item->get_transfers;
 574
 575 Return the list of outstanding transfers (i.e requested but not yet cancelled
 576 or received).
 577
 578 Note: Transfers are retrieved in a Modified FIFO (First In First Out) order
 579 whereby the most recently sent, but not received, transfer will be returned
 580 first if it exists, otherwise requests are in oldest to newest request order.
 581
 582 This allows for transfers to queue, which is the case for stock rotation and
 583 rotating collections where a manual transfer may need to take precedence but
 584 we still expect the item to end up at a final location eventually.
 585
 586 =cut
 587
 588 sub get_transfers {
 589     my ($self) = @_;
 590
 591     my $transfer_rs = $self->_result->current_branchtransfers;
 592
 593     return Koha::Item::Transfers->_new_from_dbic($transfer_rs);
 594 }
 595
 596 =head3 last_returned_by
 597
 598 Gets and sets the last patron to return an item.
 599
 600 Accepts a patron's id (borrowernumber) and returns Koha::Patron objects
 601
 602 $item->last_returned_by( $borrowernumber );
 603
 604 my $patron = $item->last_returned_by();
 605
 606 =cut
 607
 608 sub last_returned_by {
 609     my ( $self, $borrowernumber ) = @_;
 610     if ( $borrowernumber ) {
 611         $self->_result->update_or_create_related('last_returned_by',
 612             { borrowernumber => $borrowernumber, itemnumber => $self->itemnumber } );
 613     }
 614     my $rs = $self->_result->last_returned_by;
 615     return unless $rs;
 616     return Koha::Patron->_new_from_dbic($rs->borrowernumber);
 617 }
 618
 619 =head3 can_article_request
 620
 621 my $bool = $item->can_article_request( $borrower )
 622
 623 Returns true if item can be specifically requested
 624
 625 $borrower must be a Koha::Patron object
 626
 627 =cut
 628
 629 sub can_article_request {
 630     my ( $self, $borrower ) = @_;
 631
 632     my $rule = $self->article_request_type($borrower);
 633
 634     return 1 if $rule && $rule ne 'no' && $rule ne 'bib_only';
 635     return q{};
 636 }
 637
 638 =head3 hidden_in_opac
 639
 640 my $bool = $item->hidden_in_opac({ [ rules => $rules ] })
 641
 642 Returns true if item fields match the hidding criteria defined in $rules.
 643 Returns false otherwise.
 644
 645 Takes HASHref that can have the following parameters:
 646     OPTIONAL PARAMETERS:
 647     $rules : { <field> => [ value_1, ... ], ... }
 648
 649 Note: $rules inherits its structure from the parsed YAML from reading
 650 the I<OpacHiddenItems> system preference.
 651
 652 =cut
 653
 654 sub hidden_in_opac {
 655     my ( $self, $params ) = @_;
 656
 657     my $rules = $params->{rules} // {};
 658
 659     return 1
 660         if C4::Context->preference('hidelostitems') and
 661            $self->itemlost > 0;
 662
 663     my $hidden_in_opac = 0;
 664
 665     foreach my $field ( keys %{$rules} ) {
 666
 667         if ( any { $self->$field eq $_ } @{ $rules->{$field} } ) {
 668             $hidden_in_opac = 1;
 669             last;
 670         }
 671     }
 672
 673     return $hidden_in_opac;
 674 }
 675
 676 =head3 can_be_transferred
 677
 678 $item->can_be_transferred({ to => $to_library, from => $from_library })
 679 Checks if an item can be transferred to given library.
 680
 681 This feature is controlled by two system preferences:
 682 UseBranchTransferLimits to enable / disable the feature
 683 BranchTransferLimitsType to use either an itemnumber or ccode as an identifier
 684                          for setting the limitations
 685
 686 Takes HASHref that can have the following parameters:
 687     MANDATORY PARAMETERS:
 688     $to   : Koha::Library
 689     OPTIONAL PARAMETERS:
 690     $from : Koha::Library  # if not given, item holdingbranch
 691                            # will be used instead
 692
 693 Returns 1 if item can be transferred to $to_library, otherwise 0.
 694
 695 To find out whether at least one item of a Koha::Biblio can be transferred, please
 696 see Koha::Biblio->can_be_transferred() instead of using this method for
 697 multiple items of the same biblio.
 698
 699 =cut
 700
 701 sub can_be_transferred {
 702     my ($self, $params) = @_;
 703
 704     my $to   = $params->{to};
 705     my $from = $params->{from};
 706
 707     $to   = $to->branchcode;
 708     $from = defined $from ? $from->branchcode : $self->holdingbranch;
 709
 710     return 1 if $from eq $to; # Transfer to current branch is allowed
 711     return 1 unless C4::Context->preference('UseBranchTransferLimits');
 712
 713     my $limittype = C4::Context->preference('BranchTransferLimitsType');
 714     return Koha::Item::Transfer::Limits->search({
 715         toBranch => $to,
 716         fromBranch => $from,
 717         $limittype => $limittype eq 'itemtype'
 718                         ? $self->effective_itemtype : $self->ccode
 719     })->count ? 0 : 1;
 720
 721 }
 722
 723 =head3 pickup_locations
 724
 725     my $pickup_locations = $item->pickup_locations({ patron => $patron })
 726
 727 Returns possible pickup locations for this item, according to patron's home library
 728 and if item can be transferred to each pickup location.
 729
 730 Throws a I<Koha::Exceptions::MissingParameter> exception if the B<mandatory> parameter I<patron>
 731 is not passed.
 732
 733 =cut
 734
 735 sub pickup_locations {
 736     my ($self, $params) = @_;
 737
 738     Koha::Exceptions::MissingParameter->throw( parameter => 'patron' )
 739       unless exists $params->{patron};
 740
 741     my $patron = $params->{patron};
 742
 743     my $circ_control_branch =
 744       C4::Reserves::GetReservesControlBranch( $self->unblessed(), $patron->unblessed );
 745     my $branchitemrule =
 746       C4::Circulation::GetBranchItemRule( $circ_control_branch, $self->itype );
 747
 748     return Koha::Libraries->new()->empty if $branchitemrule->{holdallowed} eq 'from_local_hold_group' && !$self->home_branch->validate_hold_sibling( {branchcode => $patron->branchcode} );
 749     return Koha::Libraries->new()->empty if $branchitemrule->{holdallowed} eq 'from_home_library' && $self->home_branch->branchcode ne $patron->branchcode;
 750
 751     my $pickup_libraries = Koha::Libraries->search();
 752     if ($branchitemrule->{hold_fulfillment_policy} eq 'holdgroup') {
 753         $pickup_libraries = $self->home_branch->get_hold_libraries;
 754     } elsif ($branchitemrule->{hold_fulfillment_policy} eq 'patrongroup') {
 755         my $plib = Koha::Libraries->find({ branchcode => $patron->branchcode});
 756         $pickup_libraries = $plib->get_hold_libraries;
 757     } elsif ($branchitemrule->{hold_fulfillment_policy} eq 'homebranch') {
 758         $pickup_libraries = Koha::Libraries->search({ branchcode => $self->homebranch });
 759     } elsif ($branchitemrule->{hold_fulfillment_policy} eq 'holdingbranch') {
 760         $pickup_libraries = Koha::Libraries->search({ branchcode => $self->holdingbranch });
 761     };
 762
 763     return $pickup_libraries->search(
 764         {
 765             pickup_location => 1
 766         },
 767         {
 768             order_by => ['branchname']
 769         }
 770     ) unless C4::Context->preference('UseBranchTransferLimits');
 771
 772     my $limittype = C4::Context->preference('BranchTransferLimitsType');
 773     my ($ccode, $itype) = (undef, undef);
 774     if( $limittype eq 'ccode' ){
 775         $ccode = $self->ccode;
 776     } else {
 777         $itype = $self->itype;
 778     }
 779     my $limits = Koha::Item::Transfer::Limits->search(
 780         {
 781             fromBranch => $self->holdingbranch,
 782             ccode      => $ccode,
 783             itemtype   => $itype,
 784         },
 785         { columns => ['toBranch'] }
 786     );
 787
 788     return $pickup_libraries->search(
 789         {
 790             pickup_location => 1,
 791             branchcode      => {
 792                 '-not_in' => $limits->_resultset->as_query
 793             }
 794         },
 795         {
 796             order_by => ['branchname']
 797         }
 798     );
 799 }
 800
 801 =head3 article_request_type
 802
 803 my $type = $item->article_request_type( $borrower )
 804
 805 returns 'yes', 'no', 'bib_only', or 'item_only'
 806
 807 $borrower must be a Koha::Patron object
 808
 809 =cut
 810
 811 sub article_request_type {
 812     my ( $self, $borrower ) = @_;
 813
 814     my $branch_control = C4::Context->preference('HomeOrHoldingBranch');
 815     my $branchcode =
 816         $branch_control eq 'homebranch'    ? $self->homebranch
 817       : $branch_control eq 'holdingbranch' ? $self->holdingbranch
 818       :                                      undef;
 819     my $borrowertype = $borrower->categorycode;
 820     my $itemtype = $self->effective_itemtype();
 821     my $rule = Koha::CirculationRules->get_effective_rule(
 822         {
 823             rule_name    => 'article_requests',
 824             categorycode => $borrowertype,
 825             itemtype     => $itemtype,
 826             branchcode   => $branchcode
 827         }
 828     );
 829
 830     return q{} unless $rule;
 831     return $rule->rule_value || q{}
 832 }
 833
 834 =head3 current_holds
 835
 836 =cut
 837
 838 sub current_holds {
 839     my ( $self ) = @_;
 840     my $attributes = { order_by => 'priority' };
 841     my $dtf = Koha::Database->new->schema->storage->datetime_parser;
 842     my $params = {
 843         itemnumber => $self->itemnumber,
 844         suspend => 0,
 845         -or => [
 846             reservedate => { '<=' => $dtf->format_date(dt_from_string) },
 847             waitingdate => { '!=' => undef },
 848         ],
 849     };
 850     my $hold_rs = $self->_result->reserves->search( $params, $attributes );
 851     return Koha::Holds->_new_from_dbic($hold_rs);
 852 }
 853
 854 =head3 stockrotationitem
 855
 856   my $sritem = Koha::Item->stockrotationitem;
 857
 858 Returns the stock rotation item associated with the current item.
 859
 860 =cut
 861
 862 sub stockrotationitem {
 863     my ( $self ) = @_;
 864     my $rs = $self->_result->stockrotationitem;
 865     return 0 if !$rs;
 866     return Koha::StockRotationItem->_new_from_dbic( $rs );
 867 }
 868
 869 =head3 add_to_rota
 870
 871   my $item = $item->add_to_rota($rota_id);
 872
 873 Add this item to the rota identified by $ROTA_ID, which means associating it
 874 with the first stage of that rota.  Should this item already be associated
 875 with a rota, then we will move it to the new rota.
 876
 877 =cut
 878
 879 sub add_to_rota {
 880     my ( $self, $rota_id ) = @_;
 881     Koha::StockRotationRotas->find($rota_id)->add_item($self->itemnumber);
 882     return $self;
 883 }
 884
 885 =head3 has_pending_hold
 886
 887   my $is_pending_hold = $item->has_pending_hold();
 888
 889 This method checks the tmp_holdsqueue to see if this item has been selected for a hold, but not filled yet and returns true or false
 890
 891 =cut
 892
 893 sub has_pending_hold {
 894     my ($self) = @_;
 895     return $self->_result->tmp_holdsqueue ? 1 : 0;
 896 }
 897
 898 =head3 has_pending_recall {
 899
 900   my $has_pending_recall
 901
 902 Return if whether has pending recall of not.
 903
 904 =cut
 905
 906 sub has_pending_recall {
 907     my ( $self ) = @_;
 908
 909     # FIXME Must be moved to $self->recalls
 910     return Koha::Recalls->search(
 911         {
 912             item_id   => $self->itemnumber,
 913             status    => 'waiting',
 914         }
 915     )->count;
 916 }
 917
 918 =head3 as_marc_field
 919
 920     my $field = $item->as_marc_field;
 921
 922 This method returns a MARC::Field object representing the Koha::Item object
 923 with the current mappings configuration.
 924
 925 =cut
 926
 927 sub as_marc_field {
 928     my ( $self ) = @_;
 929
 930     my ( $itemtag, $itemtagsubfield) = C4::Biblio::GetMarcFromKohaField( "items.itemnumber" );
 931
 932     my $tagslib = C4::Biblio::GetMarcStructure( 1, $self->biblio->frameworkcode, { unsafe => 1 });
 933
 934     my @subfields;
 935
 936     my $item_field = $tagslib->{$itemtag};
 937
 938     my $more_subfields = $self->additional_attributes->to_hashref;
 939     foreach my $subfield (
 940         sort {
 941                $a->{display_order} <=> $b->{display_order}
 942             || $a->{subfield} cmp $b->{subfield}
 943         } grep { ref($_) && %$_ } values %$item_field
 944     ){
 945
 946         my $kohafield = $subfield->{kohafield};
 947         my $tagsubfield = $subfield->{tagsubfield};
 948         my $value;
 949         if ( defined $kohafield && $kohafield ne '' ) {
 950             next if $kohafield !~ m{^items\.}; # That would be weird!
 951             ( my $attribute = $kohafield ) =~ s|^items\.||;
 952             $value = $self->$attribute # This call may fail if a kohafield is not a DB column but we don't want to add extra work for that there
 953                 if defined $self->$attribute and $self->$attribute ne '';
 954         } else {
 955             $value = $more_subfields->{$tagsubfield}
 956         }
 957
 958         next unless defined $value
 959             and $value ne q{};
 960
 961         if ( $subfield->{repeatable} ) {
 962             my @values = split '\|', $value;
 963             push @subfields, ( $tagsubfield => $_ ) for @values;
 964         }
 965         else {
 966             push @subfields, ( $tagsubfield => $value );
 967         }
 968
 969     }
 970
 971     return unless @subfields;
 972
 973     return MARC::Field->new(
 974         "$itemtag", ' ', ' ', @subfields
 975     );
 976 }
 977
 978 =head3 renewal_branchcode
 979
 980 Returns the branchcode to be recorded in statistics renewal of the item
 981
 982 =cut
 983
 984 sub renewal_branchcode {
 985
 986     my ($self, $params ) = @_;
 987
 988     my $interface = C4::Context->interface;
 989     my $branchcode;
 990     if ( $interface eq 'opac' ){
 991         my $renewal_branchcode = C4::Context->preference('OpacRenewalBranch');
 992         if( !defined $renewal_branchcode || $renewal_branchcode eq 'opacrenew' ){
 993             $branchcode = 'OPACRenew';
 994         }
 995         elsif ( $renewal_branchcode eq 'itemhomebranch' ) {
 996             $branchcode = $self->homebranch;
 997         }
 998         elsif ( $renewal_branchcode eq 'patronhomebranch' ) {
 999             $branchcode = $self->checkout->patron->branchcode;
1000         }
1001         elsif ( $renewal_branchcode eq 'checkoutbranch' ) {
1002             $branchcode = $self->checkout->branchcode;
1003         }
1004         else {
1005             $branchcode = "";
1006         }
1007     } else {
1008         $branchcode = ( C4::Context->userenv && defined C4::Context->userenv->{branch} )
1009             ? C4::Context->userenv->{branch} : $params->{branch};
1010     }
1011     return $branchcode;
1012 }
1013
1014 =head3 cover_images
1015
1016 Return the cover images associated with this item.
1017
1018 =cut
1019
1020 sub cover_images {
1021     my ( $self ) = @_;
1022
1023     my $cover_image_rs = $self->_result->cover_images;
1024     return unless $cover_image_rs;
1025     return Koha::CoverImages->_new_from_dbic($cover_image_rs);
1026 }
1027
1028 =head3 columns_to_str
1029
1030     my $values = $items->columns_to_str;
1031
1032 Return a hashref with the string representation of the different attribute of the item.
1033
1034 This is meant to be used for display purpose only.
1035
1036 =cut
1037
1038 sub columns_to_str {
1039     my ( $self ) = @_;
1040     my $frameworkcode = C4::Biblio::GetFrameworkCode($self->biblionumber);
1041     my $tagslib       = C4::Biblio::GetMarcStructure( 1, $frameworkcode, { unsafe => 1 } );
1042     my $mss           = C4::Biblio::GetMarcSubfieldStructure( $frameworkcode, { unsafe => 1 } );
1043
1044     my ( $itemtagfield, $itemtagsubfield) = C4::Biblio::GetMarcFromKohaField( "items.itemnumber" );
1045
1046     my $values = {};
1047     for my $column ( @{$self->_columns}) {
1048
1049         next if $column eq 'more_subfields_xml';
1050
1051         my $value = $self->$column;
1052         # Maybe we need to deal with datetime columns here, but so far we have damaged_on, itemlost_on and withdrawn_on, and they are not linked with kohafield
1053
1054         if ( not defined $value or $value eq "" ) {
1055             $values->{$column} = $value;
1056             next;
1057         }
1058
1059         my $subfield =
1060           exists $mss->{"items.$column"}
1061           ? @{ $mss->{"items.$column"} }[0] # Should we deal with several subfields??
1062           : undef;
1063
1064         $values->{$column} =
1065             $subfield
1066           ? $subfield->{authorised_value}
1067               ? C4::Biblio::GetAuthorisedValueDesc( $itemtagfield,
1068                   $subfield->{tagsubfield}, $value, '', $tagslib )
1069               : $value
1070           : $value;
1071     }
1072
1073     my $marc_more=
1074       $self->more_subfields_xml
1075       ? MARC::Record->new_from_xml( $self->more_subfields_xml, 'UTF-8' )
1076       : undef;
1077
1078     my $more_values;
1079     if ( $marc_more ) {
1080         my ( $field ) = $marc_more->fields;
1081         for my $sf ( $field->subfields ) {
1082             my $subfield_code = $sf->[0];
1083             my $value = $sf->[1];
1084             my $subfield = $tagslib->{$itemtagfield}->{$subfield_code};
1085             next unless $subfield; # We have the value but it's not mapped, data lose! No regression however.
1086             $value =
1087               $subfield->{authorised_value}
1088               ? C4::Biblio::GetAuthorisedValueDesc( $itemtagfield,
1089                 $subfield->{tagsubfield}, $value, '', $tagslib )
1090               : $value;
1091
1092             push @{$more_values->{$subfield_code}}, $value;
1093         }
1094
1095         while ( my ( $k, $v ) = each %$more_values ) {
1096             $values->{$k} = join ' | ', @$v;
1097         }
1098     }
1099
1100     return $values;
1101 }
1102
1103 =head3 additional_attributes
1104
1105     my $attributes = $item->additional_attributes;
1106     $attributes->{k} = 'new k';
1107     $item->update({ more_subfields => $attributes->to_marcxml });
1108
1109 Returns a Koha::Item::Attributes object that represents the non-mapped
1110 attributes for this item.
1111
1112 =cut
1113
1114 sub additional_attributes {
1115     my ($self) = @_;
1116
1117     return Koha::Item::Attributes->new_from_marcxml(
1118         $self->more_subfields_xml,
1119     );
1120 }
1121
1122 =head3 _set_found_trigger
1123
1124     $self->_set_found_trigger
1125
1126 Finds the most recent lost item charge for this item and refunds the patron
1127 appropriately, taking into account any payments or writeoffs already applied
1128 against the charge.
1129
1130 Internal function, not exported, called only by Koha::Item->store.
1131
1132 =cut
1133
1134 sub _set_found_trigger {
1135     my ( $self, $pre_mod_item ) = @_;
1136
1137     # Reverse any lost item charges if necessary.
1138     my $no_refund_after_days =
1139       C4::Context->preference('NoRefundOnLostReturnedItemsAge');
1140     if ($no_refund_after_days) {
1141         my $today = dt_from_string();
1142         my $lost_age_in_days =
1143           dt_from_string( $pre_mod_item->itemlost_on )->delta_days($today)
1144           ->in_units('days');
1145
1146         return $self unless $lost_age_in_days < $no_refund_after_days;
1147     }
1148
1149     my $lost_proc_return_policy = Koha::CirculationRules->get_lostreturn_policy(
1150         {
1151             item          => $self,
1152             return_branch => C4::Context->userenv
1153             ? C4::Context->userenv->{'branch'}
1154             : undef,
1155         }
1156       );
1157     my $lostreturn_policy = $lost_proc_return_policy->{lostreturn};
1158
1159     if ( $lostreturn_policy ) {
1160
1161         # refund charge made for lost book
1162         my $lost_charge = Koha::Account::Lines->search(
1163             {
1164                 itemnumber      => $self->itemnumber,
1165                 debit_type_code => 'LOST',
1166                 status          => [ undef, { '<>' => 'FOUND' } ]
1167             },
1168             {
1169                 order_by => { -desc => [ 'date', 'accountlines_id' ] },
1170                 rows     => 1
1171             }
1172         )->single;
1173
1174         if ( $lost_charge ) {
1175
1176             my $patron = $lost_charge->patron;
1177             if ( $patron ) {
1178
1179                 my $account = $patron->account;
1180
1181                 # Credit outstanding amount
1182                 my $credit_total = $lost_charge->amountoutstanding;
1183
1184                 # Use cases
1185                 if (
1186                     $lost_charge->amount > $lost_charge->amountoutstanding &&
1187                     $lostreturn_policy ne "refund_unpaid"
1188                 ) {
1189                     # some amount has been cancelled. collect the offsets that are not writeoffs
1190                     # this works because the only way to subtract from this kind of a debt is
1191                     # using the UI buttons 'Pay' and 'Write off'
1192
1193                     # We don't credit any payments if return policy is
1194                     # "refund_unpaid"
1195                     #
1196                     # In that case only unpaid/outstanding amount
1197                     # will be credited which settles the debt without
1198                     # creating extra credits
1199
1200                     my $credit_offsets = $lost_charge->debit_offsets(
1201                         {
1202                             'credit_id'               => { '!=' => undef },
1203                             'credit.credit_type_code' => { '!=' => 'Writeoff' }
1204                         },
1205                         { join => 'credit' }
1206                     );
1207
1208                     my $total_to_refund = ( $credit_offsets->count > 0 ) ?
1209                         # credits are negative on the DB
1210                         $credit_offsets->total * -1 :
1211                         0;
1212                     # Credit the outstanding amount, then add what has been
1213                     # paid to create a net credit for this amount
1214                     $credit_total += $total_to_refund;
1215                 }
1216
1217                 my $credit;
1218                 if ( $credit_total > 0 ) {
1219                     my $branchcode =
1220                       C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
1221                     $credit = $account->add_credit(
1222                         {
1223                             amount      => $credit_total,
1224                             description => 'Item found ' . $self->itemnumber,
1225                             type        => 'LOST_FOUND',
1226                             interface   => C4::Context->interface,
1227                             library_id  => $branchcode,
1228                             item_id     => $self->itemnumber,
1229                             issue_id    => $lost_charge->issue_id
1230                         }
1231                     );
1232
1233                     $credit->apply( { debits => [$lost_charge] } );
1234                     $self->add_message(
1235                         {
1236                             type    => 'info',
1237                             message => 'lost_refunded',
1238                             payload => { credit_id => $credit->id }
1239                         }
1240                     );
1241                 }
1242
1243                 # Update the account status
1244                 $lost_charge->status('FOUND');
1245                 $lost_charge->store();
1246
1247                 # Reconcile balances if required
1248                 if ( C4::Context->preference('AccountAutoReconcile') ) {
1249                     $account->reconcile_balance;
1250                 }
1251             }
1252         }
1253
1254         # possibly restore fine for lost book
1255         my $lost_overdue = Koha::Account::Lines->search(
1256             {
1257                 itemnumber      => $self->itemnumber,
1258                 debit_type_code => 'OVERDUE',
1259                 status          => 'LOST'
1260             },
1261             {
1262                 order_by => { '-desc' => 'date' },
1263                 rows     => 1
1264             }
1265         )->single;
1266         if ( $lostreturn_policy eq 'restore' && $lost_overdue ) {
1267
1268             my $patron = $lost_overdue->patron;
1269             if ($patron) {
1270                 my $account = $patron->account;
1271
1272                 # Update status of fine
1273                 $lost_overdue->status('FOUND')->store();
1274
1275                 # Find related forgive credit
1276                 my $refund = $lost_overdue->credits(
1277                     {
1278                         credit_type_code => 'FORGIVEN',
1279                         itemnumber       => $self->itemnumber,
1280                         status           => [ { '!=' => 'VOID' }, undef ]
1281                     },
1282                     { order_by => { '-desc' => 'date' }, rows => 1 }
1283                 )->single;
1284
1285                 if ( $refund ) {
1286                     # Revert the forgive credit
1287                     $refund->void({ interface => 'trigger' });
1288                     $self->add_message(
1289                         {
1290                             type    => 'info',
1291                             message => 'lost_restored',
1292                             payload => { refund_id => $refund->id }
1293                         }
1294                     );
1295                 }
1296
1297                 # Reconcile balances if required
1298                 if ( C4::Context->preference('AccountAutoReconcile') ) {
1299                     $account->reconcile_balance;
1300                 }
1301             }
1302
1303         } elsif ( $lostreturn_policy eq 'charge' && ( $lost_overdue || $lost_charge ) ) {
1304             $self->add_message(
1305                 {
1306                     type    => 'info',
1307                     message => 'lost_charge',
1308                 }
1309             );
1310         }
1311     }
1312
1313     my $processingreturn_policy = $lost_proc_return_policy->{processingreturn};
1314
1315     if ( $processingreturn_policy ) {
1316
1317         # refund processing charge made for lost book
1318         my $processing_charge = Koha::Account::Lines->search(
1319             {
1320                 itemnumber      => $self->itemnumber,
1321                 debit_type_code => 'PROCESSING',
1322                 status          => [ undef, { '<>' => 'FOUND' } ]
1323             },
1324             {
1325                 order_by => { -desc => [ 'date', 'accountlines_id' ] },
1326                 rows     => 1
1327             }
1328         )->single;
1329
1330         if ( $processing_charge ) {
1331
1332             my $patron = $processing_charge->patron;
1333             if ( $patron ) {
1334
1335                 my $account = $patron->account;
1336
1337                 # Credit outstanding amount
1338                 my $credit_total = $processing_charge->amountoutstanding;
1339
1340                 # Use cases
1341                 if (
1342                     $processing_charge->amount > $processing_charge->amountoutstanding &&
1343                     $processingreturn_policy ne "refund_unpaid"
1344                 ) {
1345                     # some amount has been cancelled. collect the offsets that are not writeoffs
1346                     # this works because the only way to subtract from this kind of a debt is
1347                     # using the UI buttons 'Pay' and 'Write off'
1348
1349                     # We don't credit any payments if return policy is
1350                     # "refund_unpaid"
1351                     #
1352                     # In that case only unpaid/outstanding amount
1353                     # will be credited which settles the debt without
1354                     # creating extra credits
1355
1356                     my $credit_offsets = $processing_charge->debit_offsets(
1357                         {
1358                             'credit_id'               => { '!=' => undef },
1359                             'credit.credit_type_code' => { '!=' => 'Writeoff' }
1360                         },
1361                         { join => 'credit' }
1362                     );
1363
1364                     my $total_to_refund = ( $credit_offsets->count > 0 ) ?
1365                         # credits are negative on the DB
1366                         $credit_offsets->total * -1 :
1367                         0;
1368                     # Credit the outstanding amount, then add what has been
1369                     # paid to create a net credit for this amount
1370                     $credit_total += $total_to_refund;
1371                 }
1372
1373                 my $credit;
1374                 if ( $credit_total > 0 ) {
1375                     my $branchcode =
1376                       C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
1377                     $credit = $account->add_credit(
1378                         {
1379                             amount      => $credit_total,
1380                             description => 'Item found ' . $self->itemnumber,
1381                             type        => 'PROCESSING_FOUND',
1382                             interface   => C4::Context->interface,
1383                             library_id  => $branchcode,
1384                             item_id     => $self->itemnumber,
1385                             issue_id    => $processing_charge->issue_id
1386                         }
1387                     );
1388
1389                     $credit->apply( { debits => [$processing_charge] } );
1390                     $self->add_message(
1391                         {
1392                             type    => 'info',
1393                             message => 'processing_refunded',
1394                             payload => { credit_id => $credit->id }
1395                         }
1396                     );
1397                 }
1398
1399                 # Update the account status
1400                 $processing_charge->status('FOUND');
1401                 $processing_charge->store();
1402
1403                 # Reconcile balances if required
1404                 if ( C4::Context->preference('AccountAutoReconcile') ) {
1405                     $account->reconcile_balance;
1406                 }
1407             }
1408         }
1409     }
1410
1411     return $self;
1412 }
1413
1414 =head3 public_read_list
1415
1416 This method returns the list of publicly readable database fields for both API and UI output purposes
1417
1418 =cut
1419
1420 sub public_read_list {
1421     return [
1422         'itemnumber',     'biblionumber',    'homebranch',
1423         'holdingbranch',  'location',        'collectioncode',
1424         'itemcallnumber', 'copynumber',      'enumchron',
1425         'barcode',        'dateaccessioned', 'itemnotes',
1426         'onloan',         'uri',             'itype',
1427         'notforloan',     'damaged',         'itemlost',
1428         'withdrawn',      'restricted'
1429     ];
1430 }
1431
1432 =head3 to_api
1433
1434 Overloaded to_api method to ensure item-level itypes is adhered to.
1435
1436 =cut
1437
1438 sub to_api {
1439     my ($self, $params) = @_;
1440
1441     my $response = $self->SUPER::to_api($params);
1442     my $overrides = {};
1443
1444     $overrides->{effective_item_type_id} = $self->effective_itemtype;
1445     $overrides->{effective_not_for_loan_status} = $self->notforloan ? $self->notforloan : $self->itemtype->notforloan;
1446
1447     return { %$response, %$overrides };
1448 }
1449
1450 =head3 to_api_mapping
1451
1452 This method returns the mapping for representing a Koha::Item object
1453 on the API.
1454
1455 =cut
1456
1457 sub to_api_mapping {
1458     return {
1459         itemnumber               => 'item_id',
1460         biblionumber             => 'biblio_id',
1461         biblioitemnumber         => undef,
1462         barcode                  => 'external_id',
1463         dateaccessioned          => 'acquisition_date',
1464         booksellerid             => 'acquisition_source',
1465         homebranch               => 'home_library_id',
1466         price                    => 'purchase_price',
1467         replacementprice         => 'replacement_price',
1468         replacementpricedate     => 'replacement_price_date',
1469         datelastborrowed         => 'last_checkout_date',
1470         datelastseen             => 'last_seen_date',
1471         stack                    => undef,
1472         notforloan               => 'not_for_loan_status',
1473         damaged                  => 'damaged_status',
1474         damaged_on               => 'damaged_date',
1475         itemlost                 => 'lost_status',
1476         itemlost_on              => 'lost_date',
1477         withdrawn                => 'withdrawn',
1478         withdrawn_on             => 'withdrawn_date',
1479         itemcallnumber           => 'callnumber',
1480         coded_location_qualifier => 'coded_location_qualifier',
1481         issues                   => 'checkouts_count',
1482         renewals                 => 'renewals_count',
1483         reserves                 => 'holds_count',
1484         restricted               => 'restricted_status',
1485         itemnotes                => 'public_notes',
1486         itemnotes_nonpublic      => 'internal_notes',
1487         holdingbranch            => 'holding_library_id',
1488         timestamp                => 'timestamp',
1489         location                 => 'location',
1490         permanent_location       => 'permanent_location',
1491         onloan                   => 'checked_out_date',
1492         cn_source                => 'call_number_source',
1493         cn_sort                  => 'call_number_sort',
1494         ccode                    => 'collection_code',
1495         materials                => 'materials_notes',
1496         uri                      => 'uri',
1497         itype                    => 'item_type_id',
1498         more_subfields_xml       => 'extended_subfields',
1499         enumchron                => 'serial_issue_number',
1500         copynumber               => 'copy_number',
1501         stocknumber              => 'inventory_number',
1502         new_status               => 'new_status',
1503         deleted_on               => undef,
1504     };
1505 }
1506
1507 =head3 itemtype
1508
1509     my $itemtype = $item->itemtype;
1510
1511     Returns Koha object for effective itemtype
1512
1513 =cut
1514
1515 sub itemtype {
1516     my ( $self ) = @_;
1517
1518     return Koha::ItemTypes->find( $self->effective_itemtype );
1519 }
1520
1521 =head3 orders
1522
1523   my $orders = $item->orders();
1524
1525 Returns a Koha::Acquisition::Orders object
1526
1527 =cut
1528
1529 sub orders {
1530     my ( $self ) = @_;
1531
1532     my $orders = $self->_result->item_orders;
1533     return Koha::Acquisition::Orders->_new_from_dbic($orders);
1534 }
1535
1536 =head3 tracked_links
1537
1538   my $tracked_links = $item->tracked_links();
1539
1540 Returns a Koha::TrackedLinks object
1541
1542 =cut
1543
1544 sub tracked_links {
1545     my ( $self ) = @_;
1546
1547     my $tracked_links = $self->_result->linktrackers;
1548     return Koha::TrackedLinks->_new_from_dbic($tracked_links);
1549 }
1550
1551 =head3 move_to_biblio
1552
1553   $item->move_to_biblio($to_biblio[, $params]);
1554
1555 Move the item to another biblio and update any references in other tables.
1556
1557 The final optional parameter, C<$params>, is expected to contain the
1558 'skip_record_index' key, which is relayed down to Koha::Item->store.
1559 There it prevents calling index_records, which takes most of the
1560 time in batch adds/deletes. The caller must take care of calling
1561 index_records separately.
1562
1563 $params:
1564     skip_record_index => 1|0
1565
1566 Returns undef if the move failed or the biblionumber of the destination record otherwise
1567
1568 =cut
1569
1570 sub move_to_biblio {
1571     my ( $self, $to_biblio, $params ) = @_;
1572
1573     $params //= {};
1574
1575     return if $self->biblionumber == $to_biblio->biblionumber;
1576
1577     my $from_biblionumber = $self->biblionumber;
1578     my $to_biblionumber = $to_biblio->biblionumber;
1579
1580     # Own biblionumber and biblioitemnumber
1581     $self->set({
1582         biblionumber => $to_biblionumber,
1583         biblioitemnumber => $to_biblio->biblioitem->biblioitemnumber
1584     })->store({ skip_record_index => $params->{skip_record_index} });
1585
1586     unless ($params->{skip_record_index}) {
1587         my $indexer = Koha::SearchEngine::Indexer->new({ index => $Koha::SearchEngine::BIBLIOS_INDEX });
1588         $indexer->index_records( $from_biblionumber, "specialUpdate", "biblioserver" );
1589     }
1590
1591     # Acquisition orders
1592     $self->orders->update({ biblionumber => $to_biblionumber }, { no_triggers => 1 });
1593
1594     # Holds
1595     $self->holds->update({ biblionumber => $to_biblionumber }, { no_triggers => 1 });
1596
1597     # hold_fill_target (there's no Koha object available yet)
1598     my $hold_fill_target = $self->_result->hold_fill_target;
1599     if ($hold_fill_target) {
1600         $hold_fill_target->update({ biblionumber => $to_biblionumber });
1601     }
1602
1603     # tmp_holdsqueues - Can't update with DBIx since the table is missing a primary key
1604     # and can't even fake one since the significant columns are nullable.
1605     my $storage = $self->_result->result_source->storage;
1606     $storage->dbh_do(
1607         sub {
1608             my ($storage, $dbh, @cols) = @_;
1609
1610             $dbh->do("UPDATE tmp_holdsqueue SET biblionumber=? WHERE itemnumber=?", undef, $to_biblionumber, $self->itemnumber);
1611         }
1612     );
1613
1614     # tracked_links
1615     $self->tracked_links->update({ biblionumber => $to_biblionumber }, { no_triggers => 1 });
1616
1617     return $to_biblionumber;
1618 }
1619
1620 =head3 bundle_items
1621
1622   my $bundle_items = $item->bundle_items;
1623
1624 Returns the items associated with this bundle
1625
1626 =cut
1627
1628 sub bundle_items {
1629     my ($self) = @_;
1630
1631     my $rs = $self->_result->bundle_items;
1632     return Koha::Items->_new_from_dbic($rs);
1633 }
1634
1635 =head3 is_bundle
1636
1637   my $is_bundle = $item->is_bundle;
1638
1639 Returns whether the item is a bundle or not
1640
1641 =cut
1642
1643 sub is_bundle {
1644     my ($self) = @_;
1645     return $self->bundle_items->count ? 1 : 0;
1646 }
1647
1648 =head3 bundle_host
1649
1650   my $bundle = $item->bundle_host;
1651
1652 Returns the bundle item this item is attached to
1653
1654 =cut
1655
1656 sub bundle_host {
1657     my ($self) = @_;
1658
1659     my $bundle_items_rs = $self->_result->item_bundles_item;
1660     return unless $bundle_items_rs;
1661     return Koha::Item->_new_from_dbic($bundle_items_rs->host);
1662 }
1663
1664 =head3 in_bundle
1665
1666   my $in_bundle = $item->in_bundle;
1667
1668 Returns whether this item is currently in a bundle
1669
1670 =cut
1671
1672 sub in_bundle {
1673     my ($self) = @_;
1674     return $self->bundle_host ? 1 : 0;
1675 }
1676
1677 =head3 add_to_bundle
1678
1679   my $link = $item->add_to_bundle($bundle_item);
1680
1681 Adds the bundle_item passed to this item
1682
1683 =cut
1684
1685 sub add_to_bundle {
1686     my ( $self, $bundle_item, $options ) = @_;
1687
1688     $options //= {};
1689
1690     Koha::Exceptions::Item::Bundle::IsBundle->throw()
1691       if ( $self->itemnumber eq $bundle_item->itemnumber
1692         || $bundle_item->is_bundle
1693         || $self->in_bundle );
1694
1695     my $schema = Koha::Database->new->schema;
1696
1697     my $BundleNotLoanValue = C4::Context->preference('BundleNotLoanValue');
1698
1699     try {
1700         $schema->txn_do(
1701             sub {
1702
1703                 Koha::Exceptions::Item::Bundle::BundleIsCheckedOut->throw if $self->checkout;
1704
1705                 my $checkout = $bundle_item->checkout;
1706                 if ($checkout) {
1707                     unless ($options->{force_checkin}) {
1708                         Koha::Exceptions::Item::Bundle::ItemIsCheckedOut->throw();
1709                     }
1710
1711                     my $branchcode = C4::Context->userenv->{'branch'};
1712                     my ($success) = C4::Circulation::AddReturn($bundle_item->barcode, $branchcode);
1713                     unless ($success) {
1714                         Koha::Exceptions::Checkin::FailedCheckin->throw();
1715                     }
1716                 }
1717
1718                 my $holds = $bundle_item->current_holds;
1719                 if ($holds->count) {
1720                     unless ($options->{ignore_holds}) {
1721                         Koha::Exceptions::Item::Bundle::ItemHasHolds->throw();
1722                     }
1723                 }
1724
1725                 $self->_result->add_to_item_bundles_hosts(
1726                     { item => $bundle_item->itemnumber } );
1727
1728                 $bundle_item->notforloan($BundleNotLoanValue)->store();
1729             }
1730         );
1731     }
1732     catch {
1733
1734         # FIXME: See if we can move the below copy/paste from Koha::Object::store into it's own class and catch at a lower level in the Schema instantiation, take inspiration from DBIx::Error
1735         if ( ref($_) eq 'DBIx::Class::Exception' ) {
1736             if ( $_->{msg} =~ /Cannot add or update a child row: a foreign key constraint fails/ ) {
1737                 # FK constraints
1738                 # FIXME: MySQL error, if we support more DB engines we should implement this for each
1739                 if ( $_->{msg} =~ /FOREIGN KEY \(`(?<column>.*?)`\)/ ) {
1740                     Koha::Exceptions::Object::FKConstraint->throw(
1741                         error     => 'Broken FK constraint',
1742                         broken_fk => $+{column}
1743                     );
1744                 }
1745             }
1746             elsif (
1747                 $_->{msg} =~ /Duplicate entry '(.*?)' for key '(?<key>.*?)'/ )
1748             {
1749                 Koha::Exceptions::Object::DuplicateID->throw(
1750                     error        => 'Duplicate ID',
1751                     duplicate_id => $+{key}
1752                 );
1753             }
1754             elsif ( $_->{msg} =~
1755 /Incorrect (?<type>\w+) value: '(?<value>.*)' for column \W?(?<property>\S+)/
1756               )
1757             {    # The optional \W in the regex might be a quote or backtick
1758                 my $type     = $+{type};
1759                 my $value    = $+{value};
1760                 my $property = $+{property};
1761                 $property =~ s/['`]//g;
1762                 Koha::Exceptions::Object::BadValue->throw(
1763                     type     => $type,
1764                     value    => $value,
1765                     property => $property =~ /(\w+\.\w+)$/
1766                     ? $1
1767                     : $property
1768                     ,    # results in table.column without quotes or backtics
1769                 );
1770             }
1771
1772             # Catch-all for foreign key breakages. It will help find other use cases
1773             $_->rethrow();
1774         }
1775         else {
1776             $_->rethrow();
1777         }
1778     };
1779 }
1780
1781 =head3 remove_from_bundle
1782
1783 Remove this item from any bundle it may have been attached to.
1784
1785 =cut
1786
1787 sub remove_from_bundle {
1788     my ($self) = @_;
1789
1790     my $bundle_host = $self->bundle_host;
1791
1792     return 0 unless $bundle_host;    # Should not we raise an exception here?
1793
1794     Koha::Exceptions::Item::Bundle::BundleIsCheckedOut->throw if $bundle_host->checkout;
1795
1796     my $bundle_item_rs = $self->_result->item_bundles_item;
1797     if ( $bundle_item_rs ) {
1798         $bundle_item_rs->delete;
1799         $self->notforloan(0)->store();
1800         return 1;
1801     }
1802     return 0;
1803 }
1804
1805 =head2 Internal methods
1806
1807 =head3 _after_item_action_hooks
1808
1809 Helper method that takes care of calling all plugin hooks
1810
1811 =cut
1812
1813 sub _after_item_action_hooks {
1814     my ( $self, $params ) = @_;
1815
1816     my $action = $params->{action};
1817
1818     Koha::Plugins->call(
1819         'after_item_action',
1820         {
1821             action  => $action,
1822             item    => $self,
1823             item_id => $self->itemnumber,
1824         }
1825     );
1826 }
1827
1828 =head3 recall
1829
1830     my $recall = $item->recall;
1831
1832 Return the relevant recall for this item
1833
1834 =cut
1835
1836 sub recall {
1837     my ( $self ) = @_;
1838     my @recalls = Koha::Recalls->search(
1839         {
1840             biblio_id => $self->biblionumber,
1841             completed => 0,
1842         },
1843         { order_by => { -asc => 'created_date' } }
1844     )->as_list;
1845     foreach my $recall (@recalls) {
1846         if ( $recall->item_level and $recall->item_id == $self->itemnumber ){
1847             return $recall;
1848         }
1849     }
1850     # no item-level recall to return, so return earliest biblio-level
1851     # FIXME: eventually this will be based on priority
1852     return $recalls[0];
1853 }
1854
1855 =head3 can_be_recalled
1856
1857     if ( $item->can_be_recalled({ patron => $patron_object }) ) # do recall
1858
1859 Does item-level checks and returns if items can be recalled by this borrower
1860
1861 =cut
1862
1863 sub can_be_recalled {
1864     my ( $self, $params ) = @_;
1865
1866     return 0 if !( C4::Context->preference('UseRecalls') );
1867
1868     # check if this item is not for loan, withdrawn or lost
1869     return 0 if ( $self->notforloan != 0 );
1870     return 0 if ( $self->itemlost != 0 );
1871     return 0 if ( $self->withdrawn != 0 );
1872
1873     # check if this item is not checked out - if not checked out, can't be recalled
1874     return 0 if ( !defined( $self->checkout ) );
1875
1876     my $patron = $params->{patron};
1877
1878     my $branchcode = C4::Context->userenv->{'branch'};
1879     if ( $patron ) {
1880         $branchcode = C4::Circulation::_GetCircControlBranch( $self->unblessed, $patron->unblessed );
1881     }
1882
1883     # Check the circulation rule for each relevant itemtype for this item
1884     my $rule = Koha::CirculationRules->get_effective_rules({
1885         branchcode => $branchcode,
1886         categorycode => $patron ? $patron->categorycode : undef,
1887         itemtype => $self->effective_itemtype,
1888         rules => [
1889             'recalls_allowed',
1890             'recalls_per_record',
1891             'on_shelf_recalls',
1892         ],
1893     });
1894
1895     # check recalls allowed has been set and is not zero
1896     return 0 if ( !defined($rule->{recalls_allowed}) || $rule->{recalls_allowed} == 0 );
1897
1898     if ( $patron ) {
1899         # check borrower has not reached open recalls allowed limit
1900         return 0 if ( $patron->recalls->filter_by_current->count >= $rule->{recalls_allowed} );
1901
1902         # check borrower has not reach open recalls allowed per record limit
1903         return 0 if ( $patron->recalls->filter_by_current->search({ biblio_id => $self->biblionumber })->count >= $rule->{recalls_per_record} );
1904
1905         # check if this patron has already recalled this item
1906         return 0 if ( Koha::Recalls->search({ item_id => $self->itemnumber, patron_id => $patron->borrowernumber })->filter_by_current->count > 0 );
1907
1908         # check if this patron has already checked out this item
1909         return 0 if ( Koha::Checkouts->search({ itemnumber => $self->itemnumber, borrowernumber => $patron->borrowernumber })->count > 0 );
1910
1911         # check if this patron has already reserved this item
1912         return 0 if ( Koha::Holds->search({ itemnumber => $self->itemnumber, borrowernumber => $patron->borrowernumber })->count > 0 );
1913     }
1914
1915     # check item availability
1916     # items are unavailable for recall if they are lost, withdrawn or notforloan
1917     my @items = Koha::Items->search({ biblionumber => $self->biblionumber, itemlost => 0, withdrawn => 0, notforloan => 0 })->as_list;
1918
1919     # if there are no available items at all, no recall can be placed
1920     return 0 if ( scalar @items == 0 );
1921
1922     my $checked_out_count = 0;
1923     foreach (@items) {
1924         if ( Koha::Checkouts->search({ itemnumber => $_->itemnumber })->count > 0 ){ $checked_out_count++; }
1925     }
1926
1927     # can't recall if on shelf recalls only allowed when all unavailable, but items are still available for checkout
1928     return 0 if ( $rule->{on_shelf_recalls} eq 'all' && $checked_out_count < scalar @items );
1929
1930     # can't recall if no items have been checked out
1931     return 0 if ( $checked_out_count == 0 );
1932
1933     # can recall
1934     return 1;
1935 }
1936
1937 =head3 can_be_waiting_recall
1938
1939     if ( $item->can_be_waiting_recall ) { # allocate item as waiting for recall
1940
1941 Checks item type and branch of circ rules to return whether this item can be used to fill a recall.
1942 At this point the item has already been recalled. We are now at the checkin and set waiting stage.
1943
1944 =cut
1945
1946 sub can_be_waiting_recall {
1947     my ( $self ) = @_;
1948
1949     return 0 if !( C4::Context->preference('UseRecalls') );
1950
1951     # check if this item is not for loan, withdrawn or lost
1952     return 0 if ( $self->notforloan != 0 );
1953     return 0 if ( $self->itemlost != 0 );
1954     return 0 if ( $self->withdrawn != 0 );
1955
1956     my $branchcode = $self->holdingbranch;
1957     if ( C4::Context->preference('CircControl') eq 'PickupLibrary' and C4::Context->userenv and C4::Context->userenv->{'branch'} ) {
1958         $branchcode = C4::Context->userenv->{'branch'};
1959     } else {
1960         $branchcode = ( C4::Context->preference('HomeOrHoldingBranch') eq 'homebranch' ) ? $self->homebranch : $self->holdingbranch;
1961     }
1962
1963     # Check the circulation rule for each relevant itemtype for this item
1964     my $most_relevant_recall = $self->check_recalls;
1965     my $rule = Koha::CirculationRules->get_effective_rules(
1966         {
1967             branchcode   => $branchcode,
1968             categorycode => $most_relevant_recall ? $most_relevant_recall->patron->categorycode : undef,
1969             itemtype     => $self->effective_itemtype,
1970             rules        => [ 'recalls_allowed', ],
1971         }
1972     );
1973
1974     # check recalls allowed has been set and is not zero
1975     return 0 if ( !defined($rule->{recalls_allowed}) || $rule->{recalls_allowed} == 0 );
1976
1977     # can recall
1978     return 1;
1979 }
1980
1981 =head3 check_recalls
1982
1983     my $recall = $item->check_recalls;
1984
1985 Get the most relevant recall for this item.
1986
1987 =cut
1988
1989 sub check_recalls {
1990     my ( $self ) = @_;
1991
1992     my @recalls = Koha::Recalls->search(
1993         {   biblio_id => $self->biblionumber,
1994             item_id   => [ $self->itemnumber, undef ]
1995         },
1996         { order_by => { -asc => 'created_date' } }
1997     )->filter_by_current->as_list;
1998
1999     my $recall;
2000     # iterate through relevant recalls to find the best one.
2001     # if we come across a waiting recall, use this one.
2002     # if we have iterated through all recalls and not found a waiting recall, use the first recall in the array, which should be the oldest recall.
2003     foreach my $r ( @recalls ) {
2004         if ( $r->waiting ) {
2005             $recall = $r;
2006             last;
2007         }
2008     }
2009     unless ( defined $recall ) {
2010         $recall = $recalls[0];
2011     }
2012
2013     return $recall;
2014 }
2015
2016 =head3 is_notforloan
2017
2018     my $is_notforloan = $item->is_notforloan;
2019
2020 Determine whether or not this item is "notforloan" based on
2021 the item's notforloan status or its item type
2022
2023 =cut
2024
2025 sub is_notforloan {
2026     my ( $self ) = @_;
2027     my $is_notforloan = 0;
2028
2029     if ( $self->notforloan ){
2030         $is_notforloan = 1;
2031     }
2032     else {
2033         my $itemtype = $self->itemtype;
2034         if ($itemtype){
2035             if ( $itemtype->notforloan ){
2036                 $is_notforloan = 1;
2037             }
2038         }
2039     }
2040
2041     return $is_notforloan;
2042 }
2043
2044 =head3 is_denied_renewal
2045
2046     my $is_denied_renewal = $item->is_denied_renewal;
2047
2048 Determine whether or not this item can be renewed based on the
2049 rules set in the ItemsDeniedRenewal system preference.
2050
2051 =cut
2052
2053 sub is_denied_renewal {
2054     my ( $self ) = @_;
2055     my $denyingrules = C4::Context->yaml_preference('ItemsDeniedRenewal');
2056     return 0 unless $denyingrules;
2057     foreach my $field (keys %$denyingrules) {
2058         # Silently ignore bad column names; TODO we should validate elsewhere
2059         next if !$self->_result->result_source->has_column($field);
2060         my $val = $self->$field;
2061         if( !defined $val) {
2062             if ( any { !defined $_ }  @{$denyingrules->{$field}} ){
2063                 return 1;
2064             }
2065         } elsif (any { defined($_) && $val eq $_ } @{$denyingrules->{$field}}) {
2066            # If the results matches the values in the syspref
2067            # We return true if match found
2068             return 1;
2069         }
2070     }
2071     return 0;
2072 }
2073
2074 =head3 strings_map
2075
2076 Returns a map of column name to string representations including the string,
2077 the mapping type and the mapping category where appropriate.
2078
2079 Currently handles authorised value mappings, library, callnumber and itemtype
2080 expansions.
2081
2082 Accepts a param hashref where the 'public' key denotes whether we want the public
2083 or staff client strings.
2084
2085 =cut
2086
2087 sub strings_map {
2088     my ( $self, $params ) = @_;
2089     my $frameworkcode = C4::Biblio::GetFrameworkCode($self->biblionumber);
2090     my $tagslib       = C4::Biblio::GetMarcStructure( 1, $frameworkcode, { unsafe => 1 } );
2091     my $mss           = C4::Biblio::GetMarcSubfieldStructure( $frameworkcode, { unsafe => 1 } );
2092
2093     my ( $itemtagfield, $itemtagsubfield ) = C4::Biblio::GetMarcFromKohaField("items.itemnumber");
2094
2095     # Hardcoded known 'authorised_value' values mapped to API codes
2096     my $code_to_type = {
2097         branches  => 'library',
2098         cn_source => 'call_number_source',
2099         itemtypes => 'item_type',
2100     };
2101
2102     # Handle not null and default values for integers and dates
2103     my $strings = {};
2104
2105     foreach my $col ( @{$self->_columns} ) {
2106
2107         # By now, we are done with known columns, now check the framework for mappings
2108         my $field = $self->_result->result_source->name . '.' . $col;
2109
2110         # Check there's an entry in the MARC subfield structure for the field
2111         if (   exists $mss->{$field}
2112             && scalar @{ $mss->{$field} } > 0
2113             && $mss->{$field}[0]->{authorised_value} )
2114         {
2115             my $subfield = $mss->{$field}[0];
2116             my $code     = $subfield->{authorised_value};
2117
2118             my $str  = C4::Biblio::GetAuthorisedValueDesc( $itemtagfield, $subfield->{tagsubfield}, $self->$col, '', $tagslib, undef, $params->{public} );
2119             my $type = exists $code_to_type->{$code} ? $code_to_type->{$code} : 'av';
2120             $strings->{$col} = {
2121                 str  => $str,
2122                 type => $type,
2123                 ( $type eq 'av' ? ( category => $code ) : () ),
2124             };
2125         }
2126     }
2127
2128     return $strings;
2129 }
2130
2131 =head3 _type
2132
2133 =cut
2134
2135 sub _type {
2136     return 'Item';
2137 }
2138
2139 =head1 AUTHOR
2140
2141 Kyle M Hall <kyle@bywatersolutions.com>
2142
2143 =cut
2144
2145 1;