Bug 26963: (QA follow-up) Convert to ResultSets
[koha.git] / 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
556 =head3 pickup_locations
557
558 $pickup_locations = $item->pickup_locations( {patron => $patron } )
559
560 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)
561 and if item can be transferred to each pickup location.
562
563 =cut
564
565 sub pickup_locations {
566     my ($self, $params) = @_;
567
568     my $patron = $params->{patron};
569
570     my $circ_control_branch =
571       C4::Reserves::GetReservesControlBranch( $self->unblessed(), $patron->unblessed );
572     my $branchitemrule =
573       C4::Circulation::GetBranchItemRule( $circ_control_branch, $self->itype );
574
575     if(defined $patron) {
576         return Koha::Libraries->new()->empty if $branchitemrule->{holdallowed} == 3 && !$self->home_branch->validate_hold_sibling( {branchcode => $patron->branchcode} );
577         return Koha::Libraries->new()->empty if $branchitemrule->{holdallowed} == 1 && $self->home_branch->branchcode ne $patron->branchcode;
578     }
579
580     my $pickup_libraries = Koha::Libraries->search();
581     if ($branchitemrule->{hold_fulfillment_policy} eq 'holdgroup') {
582         $pickup_libraries = $self->home_branch->get_hold_libraries;
583     } elsif ($branchitemrule->{hold_fulfillment_policy} eq 'patrongroup') {
584         my $plib = Koha::Libraries->find({ branchcode => $patron->branchcode});
585         $pickup_libraries = $plib->get_hold_libraries;
586     } elsif ($branchitemrule->{hold_fulfillment_policy} eq 'homebranch') {
587         $pickup_libraries = Koha::Libraries->search({ branchcode => $self->homebranch });
588     } elsif ($branchitemrule->{hold_fulfillment_policy} eq 'holdingbranch') {
589         $pickup_libraries = Koha::Libraries->search({ branchcode => $self->holdingbranch });
590     };
591
592     return $pickup_libraries->search(
593         {
594             pickup_location => 1
595         },
596         {
597             order_by => ['branchname']
598         }
599     ) unless C4::Context->preference('UseBranchTransferLimits');
600
601     my $limittype = C4::Context->preference('BranchTransferLimitsType');
602     my $limiter = $limittype eq 'itemtype' ? $self->effective_itemtype : $self->ccode;
603     my $limits = Koha::Item::Transfer::Limits->search(
604         {
605             fromBranch => $self->holdingbranch,
606             $limittype => $limiter
607         },
608         { columns => ['toBranch'] }
609     );
610
611     return $pickup_libraries->search(
612         {
613             pickup_location => 1,
614             branchcode      => {
615                 '-not_in' => $limits->_resultset->as_query
616             }
617         },
618         {
619             order_by => ['branchname']
620         }
621     );
622 }
623
624 =head3 article_request_type
625
626 my $type = $item->article_request_type( $borrower )
627
628 returns 'yes', 'no', 'bib_only', or 'item_only'
629
630 $borrower must be a Koha::Patron object
631
632 =cut
633
634 sub article_request_type {
635     my ( $self, $borrower ) = @_;
636
637     my $branch_control = C4::Context->preference('HomeOrHoldingBranch');
638     my $branchcode =
639         $branch_control eq 'homebranch'    ? $self->homebranch
640       : $branch_control eq 'holdingbranch' ? $self->holdingbranch
641       :                                      undef;
642     my $borrowertype = $borrower->categorycode;
643     my $itemtype = $self->effective_itemtype();
644     my $rule = Koha::CirculationRules->get_effective_rule(
645         {
646             rule_name    => 'article_requests',
647             categorycode => $borrowertype,
648             itemtype     => $itemtype,
649             branchcode   => $branchcode
650         }
651     );
652
653     return q{} unless $rule;
654     return $rule->rule_value || q{}
655 }
656
657 =head3 current_holds
658
659 =cut
660
661 sub current_holds {
662     my ( $self ) = @_;
663     my $attributes = { order_by => 'priority' };
664     my $dtf = Koha::Database->new->schema->storage->datetime_parser;
665     my $params = {
666         itemnumber => $self->itemnumber,
667         suspend => 0,
668         -or => [
669             reservedate => { '<=' => $dtf->format_date(dt_from_string) },
670             waitingdate => { '!=' => undef },
671         ],
672     };
673     my $hold_rs = $self->_result->reserves->search( $params, $attributes );
674     return Koha::Holds->_new_from_dbic($hold_rs);
675 }
676
677 =head3 stockrotationitem
678
679   my $sritem = Koha::Item->stockrotationitem;
680
681 Returns the stock rotation item associated with the current item.
682
683 =cut
684
685 sub stockrotationitem {
686     my ( $self ) = @_;
687     my $rs = $self->_result->stockrotationitem;
688     return 0 if !$rs;
689     return Koha::StockRotationItem->_new_from_dbic( $rs );
690 }
691
692 =head3 add_to_rota
693
694   my $item = $item->add_to_rota($rota_id);
695
696 Add this item to the rota identified by $ROTA_ID, which means associating it
697 with the first stage of that rota.  Should this item already be associated
698 with a rota, then we will move it to the new rota.
699
700 =cut
701
702 sub add_to_rota {
703     my ( $self, $rota_id ) = @_;
704     Koha::StockRotationRotas->find($rota_id)->add_item($self->itemnumber);
705     return $self;
706 }
707
708 =head3 has_pending_hold
709
710   my $is_pending_hold = $item->has_pending_hold();
711
712 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
713
714 =cut
715
716 sub has_pending_hold {
717     my ( $self ) = @_;
718     my $pending_hold = $self->_result->tmp_holdsqueues;
719     return $pending_hold->count ? 1: 0;
720 }
721
722 =head3 as_marc_field
723
724     my $mss   = C4::Biblio::GetMarcSubfieldStructure( '', { unsafe => 1 } );
725     my $field = $item->as_marc_field({ [ mss => $mss ] });
726
727 This method returns a MARC::Field object representing the Koha::Item object
728 with the current mappings configuration.
729
730 =cut
731
732 sub as_marc_field {
733     my ( $self, $params ) = @_;
734
735     my $mss = $params->{mss} // C4::Biblio::GetMarcSubfieldStructure( '', { unsafe => 1 } );
736     my $item_tag = $mss->{'items.itemnumber'}[0]->{tagfield};
737
738     my @subfields;
739
740     my @columns = $self->_result->result_source->columns;
741
742     foreach my $item_field ( @columns ) {
743         my $mapping = $mss->{ "items.$item_field"}[0];
744         my $tagfield    = $mapping->{tagfield};
745         my $tagsubfield = $mapping->{tagsubfield};
746         next if !$tagfield; # TODO: Should we raise an exception instead?
747                             # Feels like safe fallback is better
748
749         push @subfields, $tagsubfield => $self->$item_field
750             if defined $self->$item_field and $item_field ne '';
751     }
752
753     my $unlinked_item_subfields = C4::Items::_parse_unlinked_item_subfields_from_xml($self->more_subfields_xml);
754     push( @subfields, @{$unlinked_item_subfields} )
755         if defined $unlinked_item_subfields and $#$unlinked_item_subfields > -1;
756
757     my $field;
758
759     $field = MARC::Field->new(
760         "$item_tag", ' ', ' ', @subfields
761     ) if @subfields;
762
763     return $field;
764 }
765
766 =head3 renewal_branchcode
767
768 Returns the branchcode to be recorded in statistics renewal of the item
769
770 =cut
771
772 sub renewal_branchcode {
773
774     my ($self, $params ) = @_;
775
776     my $interface = C4::Context->interface;
777     my $branchcode;
778     if ( $interface eq 'opac' ){
779         my $renewal_branchcode = C4::Context->preference('OpacRenewalBranch');
780         if( !defined $renewal_branchcode || $renewal_branchcode eq 'opacrenew' ){
781             $branchcode = 'OPACRenew';
782         }
783         elsif ( $renewal_branchcode eq 'itemhomebranch' ) {
784             $branchcode = $self->homebranch;
785         }
786         elsif ( $renewal_branchcode eq 'patronhomebranch' ) {
787             $branchcode = $self->checkout->patron->branchcode;
788         }
789         elsif ( $renewal_branchcode eq 'checkoutbranch' ) {
790             $branchcode = $self->checkout->branchcode;
791         }
792         else {
793             $branchcode = "";
794         }
795     } else {
796         $branchcode = ( C4::Context->userenv && defined C4::Context->userenv->{branch} )
797             ? C4::Context->userenv->{branch} : $params->{branch};
798     }
799     return $branchcode;
800 }
801
802 =head3 cover_images
803
804 Return the cover images associated with this item.
805
806 =cut
807
808 sub cover_images {
809     my ( $self ) = @_;
810
811     my $cover_image_rs = $self->_result->cover_images;
812     return unless $cover_image_rs;
813     return Koha::CoverImages->_new_from_dbic($cover_image_rs);
814 }
815
816 =head3 _set_found_trigger
817
818     $self->_set_found_trigger
819
820 Finds the most recent lost item charge for this item and refunds the patron
821 appropriately, taking into account any payments or writeoffs already applied
822 against the charge.
823
824 Internal function, not exported, called only by Koha::Item->store.
825
826 =cut
827
828 sub _set_found_trigger {
829     my ( $self, $pre_mod_item ) = @_;
830
831     ## If item was lost, it has now been found, reverse any list item charges if necessary.
832     my $no_refund_after_days =
833       C4::Context->preference('NoRefundOnLostReturnedItemsAge');
834     if ($no_refund_after_days) {
835         my $today = dt_from_string();
836         my $lost_age_in_days =
837           dt_from_string( $pre_mod_item->itemlost_on )->delta_days($today)
838           ->in_units('days');
839
840         return $self unless $lost_age_in_days < $no_refund_after_days;
841     }
842
843     my $lostreturn_policy = Koha::CirculationRules->get_lostreturn_policy(
844         {
845             item          => $self,
846             return_branch => C4::Context->userenv
847             ? C4::Context->userenv->{'branch'}
848             : undef,
849         }
850       );
851
852     if ( $lostreturn_policy ) {
853
854         # refund charge made for lost book
855         my $lost_charge = Koha::Account::Lines->search(
856             {
857                 itemnumber      => $self->itemnumber,
858                 debit_type_code => 'LOST',
859                 status          => [ undef, { '<>' => 'FOUND' } ]
860             },
861             {
862                 order_by => { -desc => [ 'date', 'accountlines_id' ] },
863                 rows     => 1
864             }
865         )->single;
866
867         if ( $lost_charge ) {
868
869             my $patron = $lost_charge->patron;
870             if ( $patron ) {
871
872                 my $account = $patron->account;
873                 my $total_to_refund = 0;
874
875                 # Use cases
876                 if ( $lost_charge->amount > $lost_charge->amountoutstanding ) {
877
878                     # some amount has been cancelled. collect the offsets that are not writeoffs
879                     # this works because the only way to subtract from this kind of a debt is
880                     # using the UI buttons 'Pay' and 'Write off'
881                     my $credits_offsets = Koha::Account::Offsets->search(
882                         {
883                             debit_id  => $lost_charge->id,
884                             credit_id => { '!=' => undef },     # it is not the debit itself
885                             type      => { '!=' => 'Writeoff' },
886                             amount    => { '<' => 0 }    # credits are negative on the DB
887                         }
888                     );
889
890                     $total_to_refund = ( $credits_offsets->count > 0 )
891                       ? $credits_offsets->total * -1    # credits are negative on the DB
892                       : 0;
893                 }
894
895                 my $credit_total = $lost_charge->amountoutstanding + $total_to_refund;
896
897                 my $credit;
898                 if ( $credit_total > 0 ) {
899                     my $branchcode =
900                       C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
901                     $credit = $account->add_credit(
902                         {
903                             amount      => $credit_total,
904                             description => 'Item found ' . $self->itemnumber,
905                             type        => 'LOST_FOUND',
906                             interface   => C4::Context->interface,
907                             library_id  => $branchcode,
908                             item_id     => $self->itemnumber,
909                             issue_id    => $lost_charge->issue_id
910                         }
911                     );
912
913                     $credit->apply( { debits => [$lost_charge] } );
914                     $self->{_refunded} = 1;
915                 }
916
917                 # Update the account status
918                 $lost_charge->status('FOUND');
919                 $lost_charge->store();
920
921                 # Reconcile balances if required
922                 if ( C4::Context->preference('AccountAutoReconcile') ) {
923                     $account->reconcile_balance;
924                 }
925             }
926         }
927
928         # restore fine for lost book
929         if ( $lostreturn_policy eq 'restore' ) {
930             my $lost_overdue = Koha::Account::Lines->search(
931                 {
932                     itemnumber      => $self->itemnumber,
933                     debit_type_code => 'OVERDUE',
934                     status          => 'LOST'
935                 },
936                 {
937                     order_by => { '-desc' => 'date' },
938                     rows     => 1
939                 }
940             )->single;
941
942             if ( $lost_overdue ) {
943
944                 my $patron = $lost_overdue->patron;
945                 if ($patron) {
946                     my $account = $patron->account;
947
948                     # Update status of fine
949                     $lost_overdue->status('FOUND')->store();
950
951                     # Find related forgive credit
952                     my $refund = $lost_overdue->credits(
953                         {
954                             credit_type_code => 'FORGIVEN',
955                             itemnumber       => $self->itemnumber,
956                             status           => [ { '!=' => 'VOID' }, undef ]
957                         },
958                         { order_by => { '-desc' => 'date' }, rows => 1 }
959                     )->single;
960
961                     if ( $refund ) {
962                         # Revert the forgive credit
963                         $refund->void();
964                         $self->{_restored} = 1;
965                     }
966
967                     # Reconcile balances if required
968                     if ( C4::Context->preference('AccountAutoReconcile') ) {
969                         $account->reconcile_balance;
970                     }
971                 }
972             }
973         } elsif ( $lostreturn_policy eq 'charge' ) {
974             $self->{_charge} = 1;
975         }
976     }
977
978     return $self;
979 }
980
981 =head3 to_api_mapping
982
983 This method returns the mapping for representing a Koha::Item object
984 on the API.
985
986 =cut
987
988 sub to_api_mapping {
989     return {
990         itemnumber               => 'item_id',
991         biblionumber             => 'biblio_id',
992         biblioitemnumber         => undef,
993         barcode                  => 'external_id',
994         dateaccessioned          => 'acquisition_date',
995         booksellerid             => 'acquisition_source',
996         homebranch               => 'home_library_id',
997         price                    => 'purchase_price',
998         replacementprice         => 'replacement_price',
999         replacementpricedate     => 'replacement_price_date',
1000         datelastborrowed         => 'last_checkout_date',
1001         datelastseen             => 'last_seen_date',
1002         stack                    => undef,
1003         notforloan               => 'not_for_loan_status',
1004         damaged                  => 'damaged_status',
1005         damaged_on               => 'damaged_date',
1006         itemlost                 => 'lost_status',
1007         itemlost_on              => 'lost_date',
1008         withdrawn                => 'withdrawn',
1009         withdrawn_on             => 'withdrawn_date',
1010         itemcallnumber           => 'callnumber',
1011         coded_location_qualifier => 'coded_location_qualifier',
1012         issues                   => 'checkouts_count',
1013         renewals                 => 'renewals_count',
1014         reserves                 => 'holds_count',
1015         restricted               => 'restricted_status',
1016         itemnotes                => 'public_notes',
1017         itemnotes_nonpublic      => 'internal_notes',
1018         holdingbranch            => 'holding_library_id',
1019         timestamp                => 'timestamp',
1020         location                 => 'location',
1021         permanent_location       => 'permanent_location',
1022         onloan                   => 'checked_out_date',
1023         cn_source                => 'call_number_source',
1024         cn_sort                  => 'call_number_sort',
1025         ccode                    => 'collection_code',
1026         materials                => 'materials_notes',
1027         uri                      => 'uri',
1028         itype                    => 'item_type',
1029         more_subfields_xml       => 'extended_subfields',
1030         enumchron                => 'serial_issue_number',
1031         copynumber               => 'copy_number',
1032         stocknumber              => 'inventory_number',
1033         new_status               => 'new_status'
1034     };
1035 }
1036
1037 =head3 itemtype
1038
1039     my $itemtype = $item->itemtype;
1040
1041     Returns Koha object for effective itemtype
1042
1043 =cut
1044
1045 sub itemtype {
1046     my ( $self ) = @_;
1047     return Koha::ItemTypes->find( $self->effective_itemtype );
1048 }
1049
1050 =head2 Internal methods
1051
1052 =head3 _after_item_action_hooks
1053
1054 Helper method that takes care of calling all plugin hooks
1055
1056 =cut
1057
1058 sub _after_item_action_hooks {
1059     my ( $self, $params ) = @_;
1060
1061     my $action = $params->{action};
1062
1063     Koha::Plugins->call(
1064         'after_item_action',
1065         {
1066             action  => $action,
1067             item    => $self,
1068             item_id => $self->itemnumber,
1069         }
1070     );
1071 }
1072
1073 =head3 _type
1074
1075 =cut
1076
1077 sub _type {
1078     return 'Item';
1079 }
1080
1081 =head1 AUTHOR
1082
1083 Kyle M Hall <kyle@bywatersolutions.com>
1084
1085 =cut
1086
1087 1;