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