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 Carp;
  23 use List::MoreUtils qw(any);
  24 use Data::Dumper;
  25 use Try::Tiny;
  26
  27 use Koha::Database;
  28 use Koha::DateUtils qw( dt_from_string );
  29
  30 use C4::Context;
  31 use C4::Circulation;
  32 use C4::Reserves;
  33 use C4::ClassSource; # FIXME We would like to avoid that
  34 use C4::Log qw( logaction );
  35
  36 use Koha::Checkouts;
  37 use Koha::CirculationRules;
  38 use Koha::CoverImages;
  39 use Koha::SearchEngine::Indexer;
  40 use Koha::Item::Transfer::Limits;
  41 use Koha::Item::Transfers;
  42 use Koha::ItemTypes;
  43 use Koha::Patrons;
  44 use Koha::Plugins;
  45 use Koha::Libraries;
  46 use Koha::StockRotationItem;
  47 use Koha::StockRotationRotas;
  48
  49 use base qw(Koha::Object);
  50
  51 =head1 NAME
  52
  53 Koha::Item - Koha Item object class
  54
  55 =head1 API
  56
  57 =head2 Class methods
  58
  59 =cut
  60
  61 =head3 store
  62
  63     $item->store;
  64
  65 $params can take an optional 'skip_record_index' parameter.
  66 If set, the reindexation process will not happen (index_records not called)
  67
  68 NOTE: This is a temporary fix to answer a performance issue when lot of items
  69 are added (or modified) at the same time.
  70 The correct way to fix this is to make the ES reindexation process async.
  71 You should not turn it on if you do not understand what it is doing exactly.
  72
  73 =cut
  74
  75 sub store {
  76     my $self = shift;
  77     my $params = @_ ? shift : {};
  78
  79     my $log_action = $params->{log_action} // 1;
  80
  81     # We do not want to oblige callers to pass this value
  82     # Dev conveniences vs performance?
  83     unless ( $self->biblioitemnumber ) {
  84         $self->biblioitemnumber( $self->biblio->biblioitem->biblioitemnumber );
  85     }
  86
  87     # See related changes from C4::Items::AddItem
  88     unless ( $self->itype ) {
  89         $self->itype($self->biblio->biblioitem->itemtype);
  90     }
  91
  92     my $today         = dt_from_string;
  93     my $plugin_action = 'create';
  94
  95     unless ( $self->in_storage ) { #AddItem
  96         unless ( $self->permanent_location ) {
  97             $self->permanent_location($self->location);
  98         }
  99         unless ( $self->replacementpricedate ) {
 100             $self->replacementpricedate($today);
 101         }
 102         unless ( $self->datelastseen ) {
 103             $self->datelastseen($today);
 104         }
 105
 106         unless ( $self->dateaccessioned ) {
 107             $self->dateaccessioned($today);
 108         }
 109
 110         if (   $self->itemcallnumber
 111             or $self->cn_source )
 112         {
 113             my $cn_sort = GetClassSort( $self->cn_source, $self->itemcallnumber, "" );
 114             $self->cn_sort($cn_sort);
 115         }
 116
 117         logaction( "CATALOGUING", "ADD", $self->itemnumber, "item" )
 118           if $log_action && C4::Context->preference("CataloguingLog");
 119
 120     } else { # ModItem
 121
 122         $plugin_action = 'modify';
 123
 124         my %updated_columns = $self->_result->get_dirty_columns;
 125         return $self->SUPER::store unless %updated_columns;
 126
 127         # Retrieve the item for comparison if we need to
 128         my $pre_mod_item = (
 129                  exists $updated_columns{itemlost}
 130               or exists $updated_columns{withdrawn}
 131               or exists $updated_columns{damaged}
 132         ) ? $self->get_from_storage : undef;
 133
 134         # Update *_on  fields if needed
 135         # FIXME: Why not for AddItem as well?
 136         my @fields = qw( itemlost withdrawn damaged );
 137         for my $field (@fields) {
 138
 139             # If the field is defined but empty or 0, we are
 140             # removing/unsetting and thus need to clear out
 141             # the 'on' field
 142             if (   exists $updated_columns{$field}
 143                 && defined( $self->$field )
 144                 && !$self->$field )
 145             {
 146                 my $field_on = "${field}_on";
 147                 $self->$field_on(undef);
 148             }
 149             # If the field has changed otherwise, we much update
 150             # the 'on' field
 151             elsif (exists $updated_columns{$field}
 152                 && $updated_columns{$field}
 153                 && !$pre_mod_item->$field )
 154             {
 155                 my $field_on = "${field}_on";
 156                 $self->$field_on(
 157                     DateTime::Format::MySQL->format_datetime(
 158                         dt_from_string()
 159                     )
 160                 );
 161             }
 162         }
 163
 164         if (   exists $updated_columns{itemcallnumber}
 165             or exists $updated_columns{cn_source} )
 166         {
 167             my $cn_sort = GetClassSort( $self->cn_source, $self->itemcallnumber, "" );
 168             $self->cn_sort($cn_sort);
 169         }
 170
 171
 172         if (    exists $updated_columns{location}
 173             and $self->location ne 'CART'
 174             and $self->location ne 'PROC'
 175             and not exists $updated_columns{permanent_location} )
 176         {
 177             $self->permanent_location( $self->location );
 178         }
 179
 180         # If item was lost and has now been found,
 181         # reverse any list item charges if necessary.
 182         if (    exists $updated_columns{itemlost}
 183             and $updated_columns{itemlost} <= 0
 184             and $pre_mod_item->itemlost > 0 )
 185         {
 186             $self->_set_found_trigger($pre_mod_item);
 187         }
 188
 189         logaction( "CATALOGUING", "MODIFY", $self->itemnumber, "item " . Dumper($self->unblessed) )
 190           if $log_action && C4::Context->preference("CataloguingLog");
 191     }
 192
 193     unless ( $self->dateaccessioned ) {
 194         $self->dateaccessioned($today);
 195     }
 196
 197     my $result = $self->SUPER::store;
 198     my $indexer = Koha::SearchEngine::Indexer->new({ index => $Koha::SearchEngine::BIBLIOS_INDEX });
 199     $indexer->index_records( $self->biblionumber, "specialUpdate", "biblioserver" )
 200         unless $params->{skip_record_index};
 201     $self->get_from_storage->_after_item_action_hooks({ action => $plugin_action });
 202
 203     return $result;
 204 }
 205
 206 =head3 delete
 207
 208 =cut
 209
 210 sub delete {
 211     my $self = shift;
 212     my $params = @_ ? shift : {};
 213
 214     # FIXME check the item has no current issues
 215     # i.e. raise the appropriate exception
 216
 217     my $result = $self->SUPER::delete;
 218
 219     my $indexer = Koha::SearchEngine::Indexer->new({ index => $Koha::SearchEngine::BIBLIOS_INDEX });
 220     $indexer->index_records( $self->biblionumber, "specialUpdate", "biblioserver" )
 221         unless $params->{skip_record_index};
 222
 223     $self->_after_item_action_hooks({ action => 'delete' });
 224
 225     logaction( "CATALOGUING", "DELETE", $self->itemnumber, "item" )
 226       if C4::Context->preference("CataloguingLog");
 227
 228     return $result;
 229 }
 230
 231 =head3 safe_delete
 232
 233 =cut
 234
 235 sub safe_delete {
 236     my $self = shift;
 237     my $params = @_ ? shift : {};
 238
 239     my $safe_to_delete = $self->safe_to_delete;
 240     return $safe_to_delete unless $safe_to_delete eq '1';
 241
 242     $self->move_to_deleted;
 243
 244     return $self->delete($params);
 245 }
 246
 247 =head3 safe_to_delete
 248
 249 returns 1 if the item is safe to delete,
 250
 251 "book_on_loan" if the item is checked out,
 252
 253 "not_same_branch" if the item is blocked by independent branches,
 254
 255 "book_reserved" if the there are holds aganst the item, or
 256
 257 "linked_analytics" if the item has linked analytic records.
 258
 259 "last_item_for_hold" if the item is the last one on a record on which a biblio-level hold is placed
 260
 261 =cut
 262
 263 sub safe_to_delete {
 264     my ($self) = @_;
 265
 266     return "book_on_loan" if $self->checkout;
 267
 268     return "not_same_branch"
 269       if defined C4::Context->userenv
 270       and !C4::Context->IsSuperLibrarian()
 271       and C4::Context->preference("IndependentBranches")
 272       and ( C4::Context->userenv->{branch} ne $self->homebranch );
 273
 274     # check it doesn't have a waiting reserve
 275     return "book_reserved"
 276       if $self->holds->search( { found => [ 'W', 'T' ] } )->count;
 277
 278     return "linked_analytics"
 279       if C4::Items::GetAnalyticsCount( $self->itemnumber ) > 0;
 280
 281     return "last_item_for_hold"
 282       if $self->biblio->items->count == 1
 283       && $self->biblio->holds->search(
 284           {
 285               itemnumber => undef,
 286           }
 287         )->count;
 288
 289     return 1;
 290 }
 291
 292 =head3 move_to_deleted
 293
 294 my $is_moved = $item->move_to_deleted;
 295
 296 Move an item to the deleteditems table.
 297 This can be done before deleting an item, to make sure the data are not completely deleted.
 298
 299 =cut
 300
 301 sub move_to_deleted {
 302     my ($self) = @_;
 303     my $item_infos = $self->unblessed;
 304     delete $item_infos->{timestamp}; #This ensures the timestamp date in deleteditems will be set to the current timestamp
 305     return Koha::Database->new->schema->resultset('Deleteditem')->create($item_infos);
 306 }
 307
 308
 309 =head3 effective_itemtype
 310
 311 Returns the itemtype for the item based on whether item level itemtypes are set or not.
 312
 313 =cut
 314
 315 sub effective_itemtype {
 316     my ( $self ) = @_;
 317
 318     return $self->_result()->effective_itemtype();
 319 }
 320
 321 =head3 home_branch
 322
 323 =cut
 324
 325 sub home_branch {
 326     my ($self) = @_;
 327
 328     $self->{_home_branch} ||= Koha::Libraries->find( $self->homebranch() );
 329
 330     return $self->{_home_branch};
 331 }
 332
 333 =head3 holding_branch
 334
 335 =cut
 336
 337 sub holding_branch {
 338     my ($self) = @_;
 339
 340     $self->{_holding_branch} ||= Koha::Libraries->find( $self->holdingbranch() );
 341
 342     return $self->{_holding_branch};
 343 }
 344
 345 =head3 biblio
 346
 347 my $biblio = $item->biblio;
 348
 349 Return the bibliographic record of this item
 350
 351 =cut
 352
 353 sub biblio {
 354     my ( $self ) = @_;
 355     my $biblio_rs = $self->_result->biblio;
 356     return Koha::Biblio->_new_from_dbic( $biblio_rs );
 357 }
 358
 359 =head3 biblioitem
 360
 361 my $biblioitem = $item->biblioitem;
 362
 363 Return the biblioitem record of this item
 364
 365 =cut
 366
 367 sub biblioitem {
 368     my ( $self ) = @_;
 369     my $biblioitem_rs = $self->_result->biblioitem;
 370     return Koha::Biblioitem->_new_from_dbic( $biblioitem_rs );
 371 }
 372
 373 =head3 checkout
 374
 375 my $checkout = $item->checkout;
 376
 377 Return the checkout for this item
 378
 379 =cut
 380
 381 sub checkout {
 382     my ( $self ) = @_;
 383     my $checkout_rs = $self->_result->issue;
 384     return unless $checkout_rs;
 385     return Koha::Checkout->_new_from_dbic( $checkout_rs );
 386 }
 387
 388 =head3 holds
 389
 390 my $holds = $item->holds();
 391 my $holds = $item->holds($params);
 392 my $holds = $item->holds({ found => 'W'});
 393
 394 Return holds attached to an item, optionally accept a hashref of params to pass to search
 395
 396 =cut
 397
 398 sub holds {
 399     my ( $self,$params ) = @_;
 400     my $holds_rs = $self->_result->reserves->search($params);
 401     return Koha::Holds->_new_from_dbic( $holds_rs );
 402 }
 403
 404 =head3 get_transfer
 405
 406 my $transfer = $item->get_transfer;
 407
 408 Return the transfer if the item is in transit or undef
 409
 410 =cut
 411
 412 sub get_transfer {
 413     my ( $self ) = @_;
 414     my $transfer_rs = $self->_result->branchtransfers->search({ datearrived => undef })->first;
 415     return unless $transfer_rs;
 416     return Koha::Item::Transfer->_new_from_dbic( $transfer_rs );
 417 }
 418
 419 =head3 last_returned_by
 420
 421 Gets and sets the last borrower to return an item.
 422
 423 Accepts and returns Koha::Patron objects
 424
 425 $item->last_returned_by( $borrowernumber );
 426
 427 $last_returned_by = $item->last_returned_by();
 428
 429 =cut
 430
 431 sub last_returned_by {
 432     my ( $self, $borrower ) = @_;
 433
 434     my $items_last_returned_by_rs = Koha::Database->new()->schema()->resultset('ItemsLastBorrower');
 435
 436     if ($borrower) {
 437         return $items_last_returned_by_rs->update_or_create(
 438             { borrowernumber => $borrower->borrowernumber, itemnumber => $self->id } );
 439     }
 440     else {
 441         unless ( $self->{_last_returned_by} ) {
 442             my $result = $items_last_returned_by_rs->single( { itemnumber => $self->id } );
 443             if ($result) {
 444                 $self->{_last_returned_by} = Koha::Patrons->find( $result->get_column('borrowernumber') );
 445             }
 446         }
 447
 448         return $self->{_last_returned_by};
 449     }
 450 }
 451
 452 =head3 can_article_request
 453
 454 my $bool = $item->can_article_request( $borrower )
 455
 456 Returns true if item can be specifically requested
 457
 458 $borrower must be a Koha::Patron object
 459
 460 =cut
 461
 462 sub can_article_request {
 463     my ( $self, $borrower ) = @_;
 464
 465     my $rule = $self->article_request_type($borrower);
 466
 467     return 1 if $rule && $rule ne 'no' && $rule ne 'bib_only';
 468     return q{};
 469 }
 470
 471 =head3 hidden_in_opac
 472
 473 my $bool = $item->hidden_in_opac({ [ rules => $rules ] })
 474
 475 Returns true if item fields match the hidding criteria defined in $rules.
 476 Returns false otherwise.
 477
 478 Takes HASHref that can have the following parameters:
 479     OPTIONAL PARAMETERS:
 480     $rules : { <field> => [ value_1, ... ], ... }
 481
 482 Note: $rules inherits its structure from the parsed YAML from reading
 483 the I<OpacHiddenItems> system preference.
 484
 485 =cut
 486
 487 sub hidden_in_opac {
 488     my ( $self, $params ) = @_;
 489
 490     my $rules = $params->{rules} // {};
 491
 492     return 1
 493         if C4::Context->preference('hidelostitems') and
 494            $self->itemlost > 0;
 495
 496     my $hidden_in_opac = 0;
 497
 498     foreach my $field ( keys %{$rules} ) {
 499
 500         if ( any { $self->$field eq $_ } @{ $rules->{$field} } ) {
 501             $hidden_in_opac = 1;
 502             last;
 503         }
 504     }
 505
 506     return $hidden_in_opac;
 507 }
 508
 509 =head3 can_be_transferred
 510
 511 $item->can_be_transferred({ to => $to_library, from => $from_library })
 512 Checks if an item can be transferred to given library.
 513
 514 This feature is controlled by two system preferences:
 515 UseBranchTransferLimits to enable / disable the feature
 516 BranchTransferLimitsType to use either an itemnumber or ccode as an identifier
 517                          for setting the limitations
 518
 519 Takes HASHref that can have the following parameters:
 520     MANDATORY PARAMETERS:
 521     $to   : Koha::Library
 522     OPTIONAL PARAMETERS:
 523     $from : Koha::Library  # if not given, item holdingbranch
 524                            # will be used instead
 525
 526 Returns 1 if item can be transferred to $to_library, otherwise 0.
 527
 528 To find out whether at least one item of a Koha::Biblio can be transferred, please
 529 see Koha::Biblio->can_be_transferred() instead of using this method for
 530 multiple items of the same biblio.
 531
 532 =cut
 533
 534 sub can_be_transferred {
 535     my ($self, $params) = @_;
 536
 537     my $to   = $params->{to};
 538     my $from = $params->{from};
 539
 540     $to   = $to->branchcode;
 541     $from = defined $from ? $from->branchcode : $self->holdingbranch;
 542
 543     return 1 if $from eq $to; # Transfer to current branch is allowed
 544     return 1 unless C4::Context->preference('UseBranchTransferLimits');
 545
 546     my $limittype = C4::Context->preference('BranchTransferLimitsType');
 547     return Koha::Item::Transfer::Limits->search({
 548         toBranch => $to,
 549         fromBranch => $from,
 550         $limittype => $limittype eq 'itemtype'
 551                         ? $self->effective_itemtype : $self->ccode
 552     })->count ? 0 : 1;
 553 }
 554
 555 =head3 pickup_locations
 556
 557 $pickup_locations = $item->pickup_locations( {patron => $patron } )
 558
 559 Returns possible pickup locations for this item, according to patron's home library (if patron is defined and holds are allowed only from hold groups)
 560 and if item can be transferred to each pickup location.
 561
 562 =cut
 563
 564 sub pickup_locations {
 565     my ($self, $params) = @_;
 566
 567     my $patron = $params->{patron};
 568
 569     my $circ_control_branch =
 570       C4::Reserves::GetReservesControlBranch( $self->unblessed(), $patron->unblessed );
 571     my $branchitemrule =
 572       C4::Circulation::GetBranchItemRule( $circ_control_branch, $self->itype );
 573
 574     my @libs;
 575     if(defined $patron) {
 576         return \@libs if $branchitemrule->{holdallowed} == 3 && !$self->home_branch->validate_hold_sibling( {branchcode => $patron->branchcode} );
 577         return \@libs if $branchitemrule->{holdallowed} == 1 && $self->home_branch->branchcode ne $patron->branchcode;
 578     }
 579
 580     if ($branchitemrule->{hold_fulfillment_policy} eq 'holdgroup') {
 581         @libs  = $self->home_branch->get_hold_libraries;
 582         push @libs, $self->home_branch unless scalar(@libs) > 0;
 583     } elsif ($branchitemrule->{hold_fulfillment_policy} eq 'patrongroup') {
 584         my $plib = Koha::Libraries->find({ branchcode => $patron->branchcode});
 585         @libs  = $plib->get_hold_libraries;
 586         push @libs, $self->home_branch unless scalar(@libs) > 0;
 587     } elsif ($branchitemrule->{hold_fulfillment_policy} eq 'homebranch') {
 588         push @libs, $self->home_branch;
 589     } elsif ($branchitemrule->{hold_fulfillment_policy} eq 'holdingbranch') {
 590         push @libs, $self->holding_branch;
 591     } else {
 592         @libs = Koha::Libraries->search({
 593             pickup_location => 1
 594         }, {
 595             order_by => ['branchname']
 596         })->as_list;
 597     }
 598
 599     my @pickup_locations;
 600     foreach my $library (@libs) {
 601         if ($library->pickup_location && $self->can_be_transferred({ to => $library })) {
 602             push @pickup_locations, $library;
 603         }
 604     }
 605
 606     return \@pickup_locations;
 607 }
 608
 609 =head3 article_request_type
 610
 611 my $type = $item->article_request_type( $borrower )
 612
 613 returns 'yes', 'no', 'bib_only', or 'item_only'
 614
 615 $borrower must be a Koha::Patron object
 616
 617 =cut
 618
 619 sub article_request_type {
 620     my ( $self, $borrower ) = @_;
 621
 622     my $branch_control = C4::Context->preference('HomeOrHoldingBranch');
 623     my $branchcode =
 624         $branch_control eq 'homebranch'    ? $self->homebranch
 625       : $branch_control eq 'holdingbranch' ? $self->holdingbranch
 626       :                                      undef;
 627     my $borrowertype = $borrower->categorycode;
 628     my $itemtype = $self->effective_itemtype();
 629     my $rule = Koha::CirculationRules->get_effective_rule(
 630         {
 631             rule_name    => 'article_requests',
 632             categorycode => $borrowertype,
 633             itemtype     => $itemtype,
 634             branchcode   => $branchcode
 635         }
 636     );
 637
 638     return q{} unless $rule;
 639     return $rule->rule_value || q{}
 640 }
 641
 642 =head3 current_holds
 643
 644 =cut
 645
 646 sub current_holds {
 647     my ( $self ) = @_;
 648     my $attributes = { order_by => 'priority' };
 649     my $dtf = Koha::Database->new->schema->storage->datetime_parser;
 650     my $params = {
 651         itemnumber => $self->itemnumber,
 652         suspend => 0,
 653         -or => [
 654             reservedate => { '<=' => $dtf->format_date(dt_from_string) },
 655             waitingdate => { '!=' => undef },
 656         ],
 657     };
 658     my $hold_rs = $self->_result->reserves->search( $params, $attributes );
 659     return Koha::Holds->_new_from_dbic($hold_rs);
 660 }
 661
 662 =head3 stockrotationitem
 663
 664   my $sritem = Koha::Item->stockrotationitem;
 665
 666 Returns the stock rotation item associated with the current item.
 667
 668 =cut
 669
 670 sub stockrotationitem {
 671     my ( $self ) = @_;
 672     my $rs = $self->_result->stockrotationitem;
 673     return 0 if !$rs;
 674     return Koha::StockRotationItem->_new_from_dbic( $rs );
 675 }
 676
 677 =head3 add_to_rota
 678
 679   my $item = $item->add_to_rota($rota_id);
 680
 681 Add this item to the rota identified by $ROTA_ID, which means associating it
 682 with the first stage of that rota.  Should this item already be associated
 683 with a rota, then we will move it to the new rota.
 684
 685 =cut
 686
 687 sub add_to_rota {
 688     my ( $self, $rota_id ) = @_;
 689     Koha::StockRotationRotas->find($rota_id)->add_item($self->itemnumber);
 690     return $self;
 691 }
 692
 693 =head3 has_pending_hold
 694
 695   my $is_pending_hold = $item->has_pending_hold();
 696
 697 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
 698
 699 =cut
 700
 701 sub has_pending_hold {
 702     my ( $self ) = @_;
 703     my $pending_hold = $self->_result->tmp_holdsqueues;
 704     return $pending_hold->count ? 1: 0;
 705 }
 706
 707 =head3 as_marc_field
 708
 709     my $mss   = C4::Biblio::GetMarcSubfieldStructure( '', { unsafe => 1 } );
 710     my $field = $item->as_marc_field({ [ mss => $mss ] });
 711
 712 This method returns a MARC::Field object representing the Koha::Item object
 713 with the current mappings configuration.
 714
 715 =cut
 716
 717 sub as_marc_field {
 718     my ( $self, $params ) = @_;
 719
 720     my $mss = $params->{mss} // C4::Biblio::GetMarcSubfieldStructure( '', { unsafe => 1 } );
 721     my $item_tag = $mss->{'items.itemnumber'}[0]->{tagfield};
 722
 723     my @subfields;
 724
 725     my @columns = $self->_result->result_source->columns;
 726
 727     foreach my $item_field ( @columns ) {
 728         my $mapping = $mss->{ "items.$item_field"}[0];
 729         my $tagfield    = $mapping->{tagfield};
 730         my $tagsubfield = $mapping->{tagsubfield};
 731         next if !$tagfield; # TODO: Should we raise an exception instead?
 732                             # Feels like safe fallback is better
 733
 734         push @subfields, $tagsubfield => $self->$item_field
 735             if defined $self->$item_field and $item_field ne '';
 736     }
 737
 738     my $unlinked_item_subfields = C4::Items::_parse_unlinked_item_subfields_from_xml($self->more_subfields_xml);
 739     push( @subfields, @{$unlinked_item_subfields} )
 740         if defined $unlinked_item_subfields and $#$unlinked_item_subfields > -1;
 741
 742     my $field;
 743
 744     $field = MARC::Field->new(
 745         "$item_tag", ' ', ' ', @subfields
 746     ) if @subfields;
 747
 748     return $field;
 749 }
 750
 751 =head3 renewal_branchcode
 752
 753 Returns the branchcode to be recorded in statistics renewal of the item
 754
 755 =cut
 756
 757 sub renewal_branchcode {
 758
 759     my ($self, $params ) = @_;
 760
 761     my $interface = C4::Context->interface;
 762     my $branchcode;
 763     if ( $interface eq 'opac' ){
 764         my $renewal_branchcode = C4::Context->preference('OpacRenewalBranch');
 765         if( !defined $renewal_branchcode || $renewal_branchcode eq 'opacrenew' ){
 766             $branchcode = 'OPACRenew';
 767         }
 768         elsif ( $renewal_branchcode eq 'itemhomebranch' ) {
 769             $branchcode = $self->homebranch;
 770         }
 771         elsif ( $renewal_branchcode eq 'patronhomebranch' ) {
 772             $branchcode = $self->checkout->patron->branchcode;
 773         }
 774         elsif ( $renewal_branchcode eq 'checkoutbranch' ) {
 775             $branchcode = $self->checkout->branchcode;
 776         }
 777         else {
 778             $branchcode = "";
 779         }
 780     } else {
 781         $branchcode = ( C4::Context->userenv && defined C4::Context->userenv->{branch} )
 782             ? C4::Context->userenv->{branch} : $params->{branch};
 783     }
 784     return $branchcode;
 785 }
 786
 787 =head3 cover_images
 788
 789 Return the cover images associated with this item.
 790
 791 =cut
 792
 793 sub cover_images {
 794     my ( $self ) = @_;
 795
 796     my $cover_image_rs = $self->_result->cover_images;
 797     return unless $cover_image_rs;
 798     return Koha::CoverImages->_new_from_dbic($cover_image_rs);
 799 }
 800
 801 =head3 _set_found_trigger
 802
 803     $self->_set_found_trigger
 804
 805 Finds the most recent lost item charge for this item and refunds the patron
 806 appropriately, taking into account any payments or writeoffs already applied
 807 against the charge.
 808
 809 Internal function, not exported, called only by Koha::Item->store.
 810
 811 =cut
 812
 813 sub _set_found_trigger {
 814     my ( $self, $pre_mod_item ) = @_;
 815
 816     ## If item was lost, it has now been found, reverse any list item charges if necessary.
 817     my $no_refund_after_days =
 818       C4::Context->preference('NoRefundOnLostReturnedItemsAge');
 819     if ($no_refund_after_days) {
 820         my $today = dt_from_string();
 821         my $lost_age_in_days =
 822           dt_from_string( $pre_mod_item->itemlost_on )->delta_days($today)
 823           ->in_units('days');
 824
 825         return $self unless $lost_age_in_days < $no_refund_after_days;
 826     }
 827
 828     return $self
 829       unless Koha::CirculationRules->get_lostreturn_policy(
 830         {
 831             item          => $self,
 832             return_branch => C4::Context->userenv
 833             ? C4::Context->userenv->{'branch'}
 834             : undef,
 835         }
 836       );
 837
 838     # check for charge made for lost book
 839     my $accountlines = Koha::Account::Lines->search(
 840         {
 841             itemnumber      => $self->itemnumber,
 842             debit_type_code => 'LOST',
 843             status          => [ undef, { '<>' => 'FOUND' } ]
 844         },
 845         {
 846             order_by => { -desc => [ 'date', 'accountlines_id' ] }
 847         }
 848     );
 849
 850     return $self unless $accountlines->count > 0;
 851
 852     my $accountline     = $accountlines->next;
 853     my $total_to_refund = 0;
 854
 855     return $self unless $accountline->borrowernumber;
 856
 857     my $patron = Koha::Patrons->find( $accountline->borrowernumber );
 858     return $self
 859       unless $patron;  # Patron has been deleted, nobody to credit the return to
 860                        # FIXME Should not we notify this somewhere
 861
 862     my $account = $patron->account;
 863
 864     # Use cases
 865     if ( $accountline->amount > $accountline->amountoutstanding ) {
 866
 867     # some amount has been cancelled. collect the offsets that are not writeoffs
 868     # this works because the only way to subtract from this kind of a debt is
 869     # using the UI buttons 'Pay' and 'Write off'
 870         my $credits_offsets = Koha::Account::Offsets->search(
 871             {
 872                 debit_id  => $accountline->id,
 873                 credit_id => { '!=' => undef },     # it is not the debit itself
 874                 type      => { '!=' => 'Writeoff' },
 875                 amount => { '<' => 0 }    # credits are negative on the DB
 876             }
 877         );
 878
 879         $total_to_refund = ( $credits_offsets->count > 0 )
 880           ? $credits_offsets->total * -1    # credits are negative on the DB
 881           : 0;
 882     }
 883
 884     my $credit_total = $accountline->amountoutstanding + $total_to_refund;
 885
 886     my $credit;
 887     if ( $credit_total > 0 ) {
 888         my $branchcode =
 889           C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
 890         $credit = $account->add_credit(
 891             {
 892                 amount      => $credit_total,
 893                 description => 'Item found ' . $self->itemnumber,
 894                 type        => 'LOST_FOUND',
 895                 interface   => C4::Context->interface,
 896                 library_id  => $branchcode,
 897                 item_id     => $self->itemnumber,
 898                 issue_id    => $accountline->issue_id
 899             }
 900         );
 901
 902         $credit->apply( { debits => [$accountline] } );
 903         $self->{_refunded} = 1;
 904     }
 905
 906     # Update the account status
 907     $accountline->status('FOUND');
 908     $accountline->store();
 909
 910     if ( defined $account and C4::Context->preference('AccountAutoReconcile') ) {
 911         $account->reconcile_balance;
 912     }
 913
 914     return $self;
 915 }
 916
 917 =head3 to_api_mapping
 918
 919 This method returns the mapping for representing a Koha::Item object
 920 on the API.
 921
 922 =cut
 923
 924 sub to_api_mapping {
 925     return {
 926         itemnumber               => 'item_id',
 927         biblionumber             => 'biblio_id',
 928         biblioitemnumber         => undef,
 929         barcode                  => 'external_id',
 930         dateaccessioned          => 'acquisition_date',
 931         booksellerid             => 'acquisition_source',
 932         homebranch               => 'home_library_id',
 933         price                    => 'purchase_price',
 934         replacementprice         => 'replacement_price',
 935         replacementpricedate     => 'replacement_price_date',
 936         datelastborrowed         => 'last_checkout_date',
 937         datelastseen             => 'last_seen_date',
 938         stack                    => undef,
 939         notforloan               => 'not_for_loan_status',
 940         damaged                  => 'damaged_status',
 941         damaged_on               => 'damaged_date',
 942         itemlost                 => 'lost_status',
 943         itemlost_on              => 'lost_date',
 944         withdrawn                => 'withdrawn',
 945         withdrawn_on             => 'withdrawn_date',
 946         itemcallnumber           => 'callnumber',
 947         coded_location_qualifier => 'coded_location_qualifier',
 948         issues                   => 'checkouts_count',
 949         renewals                 => 'renewals_count',
 950         reserves                 => 'holds_count',
 951         restricted               => 'restricted_status',
 952         itemnotes                => 'public_notes',
 953         itemnotes_nonpublic      => 'internal_notes',
 954         holdingbranch            => 'holding_library_id',
 955         timestamp                => 'timestamp',
 956         location                 => 'location',
 957         permanent_location       => 'permanent_location',
 958         onloan                   => 'checked_out_date',
 959         cn_source                => 'call_number_source',
 960         cn_sort                  => 'call_number_sort',
 961         ccode                    => 'collection_code',
 962         materials                => 'materials_notes',
 963         uri                      => 'uri',
 964         itype                    => 'item_type',
 965         more_subfields_xml       => 'extended_subfields',
 966         enumchron                => 'serial_issue_number',
 967         copynumber               => 'copy_number',
 968         stocknumber              => 'inventory_number',
 969         new_status               => 'new_status'
 970     };
 971 }
 972
 973 =head3 itemtype
 974
 975     my $itemtype = $item->itemtype;
 976
 977     Returns Koha object for effective itemtype
 978
 979 =cut
 980
 981 sub itemtype {
 982     my ( $self ) = @_;
 983     return Koha::ItemTypes->find( $self->effective_itemtype );
 984 }
 985
 986 =head2 Internal methods
 987
 988 =head3 _after_item_action_hooks
 989
 990 Helper method that takes care of calling all plugin hooks
 991
 992 =cut
 993
 994 sub _after_item_action_hooks {
 995     my ( $self, $params ) = @_;
 996
 997     my $action = $params->{action};
 998
 999     Koha::Plugins->call(
1000         'after_item_action',
1001         {
1002             action  => $action,
1003             item    => $self,
1004             item_id => $self->itemnumber,
1005         }
1006     );
1007 }
1008
1009 =head3 _type
1010
1011 =cut
1012
1013 sub _type {
1014     return 'Item';
1015 }
1016
1017 =head1 AUTHOR
1018
1019 Kyle M Hall <kyle@bywatersolutions.com>
1020
1021 =cut
1022
1023 1;