1 package C4::Circulation;
3 # Copyright 2000-2002 Katipo Communications
4 # copyright 2010 BibLibre
6 # This file is part of Koha.
8 # Koha is free software; you can redistribute it and/or modify it
9 # under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 3 of the License, or
11 # (at your option) any later version.
13 # Koha is distributed in the hope that it will be useful, but
14 # WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 # GNU General Public License for more details.
18 # You should have received a copy of the GNU General Public License
19 # along with Koha; if not, see <http://www.gnu.org/licenses>.
23 use POSIX qw( floor );
32 use C4::ItemCirculationAlertPreference;
35 use C4::Log; # logaction
36 use C4::Overdues qw(CalcFine UpdateFine get_chargeable_units);
37 use C4::RotatingCollections qw(GetCollectionItemBranches);
38 use Algorithm::CheckDigits;
42 use Koha::AuthorisedValues;
43 use Koha::Biblioitems;
47 use Koha::Illrequests;
50 use Koha::Patron::Debarments;
53 use Koha::Account::Lines;
55 use Koha::RefundLostItemFeeRules;
56 use Koha::Account::Lines;
57 use Koha::Account::Offsets;
58 use Koha::Config::SysPrefs;
59 use Koha::Charges::Fees;
60 use Koha::Util::SystemPreferences;
61 use Koha::Checkouts::ReturnClaims;
63 use List::MoreUtils qw( uniq any );
64 use Scalar::Util qw( looks_like_number );
75 use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
81 # FIXME subs that should probably be elsewhere
86 &GetPendingOnSiteCheckouts
89 # subs to deal with issuing a book
97 &GetLatestAutoRenewDate
99 &GetBranchBorrowerCircRule
103 &CheckIfIssuedToPatron
108 # subs to deal with returns
114 # subs to deal with transfers
121 &IsBranchTransferAllowed
122 &CreateBranchTransferLimit
123 &DeleteBranchTransferLimits
127 # subs to deal with offline circulation
129 &GetOfflineOperations
132 &DeleteOfflineOperation
133 &ProcessOfflineOperation
139 C4::Circulation - Koha circulation module
147 The functions in this module deal with circulation, issues, and
148 returns, as well as general information about the library.
149 Also deals with inventory.
155 $str = &barcodedecode($barcode, [$filter]);
157 Generic filter function for barcode string.
158 Called on every circ if the System Pref itemBarcodeInputFilter is set.
159 Will do some manipulation of the barcode for systems that deliver a barcode
160 to circulation.pl that differs from the barcode stored for the item.
161 For proper functioning of this filter, calling the function on the
162 correct barcode string (items.barcode) should return an unaltered barcode.
164 The optional $filter argument is to allow for testing or explicit
165 behavior that ignores the System Pref. Valid values are the same as the
170 # FIXME -- the &decode fcn below should be wrapped into this one.
171 # FIXME -- these plugins should be moved out of Circulation.pm
174 my ($barcode, $filter) = @_;
175 my $branch = C4::Context::mybranch();
176 $filter = C4::Context->preference('itemBarcodeInputFilter') unless $filter;
177 $filter or return $barcode; # ensure filter is defined, else return untouched barcode
178 if ($filter eq 'whitespace') {
180 } elsif ($filter eq 'cuecat') {
182 my @fields = split( /\./, $barcode );
183 my @results = map( decode($_), @fields[ 1 .. $#fields ] );
184 ($#results == 2) and return $results[2];
185 } elsif ($filter eq 'T-prefix') {
186 if ($barcode =~ /^[Tt](\d)/) {
187 (defined($1) and $1 eq '0') and return $barcode;
188 $barcode = substr($barcode, 2) + 0; # FIXME: probably should be substr($barcode, 1)
190 return sprintf("T%07d", $barcode);
191 # FIXME: $barcode could be "T1", causing warning: substr outside of string
192 # Why drop the nonzero digit after the T?
193 # Why pass non-digits (or empty string) to "T%07d"?
194 } elsif ($filter eq 'libsuite8') {
195 unless($barcode =~ m/^($branch)-/i){ #if barcode starts with branch code its in Koha style. Skip it.
196 if($barcode =~ m/^(\d)/i){ #Some barcodes even start with 0's & numbers and are assumed to have b as the item type in the libsuite8 software
197 $barcode =~ s/^[0]*(\d+)$/$branch-b-$1/i;
199 $barcode =~ s/^(\D+)[0]*(\d+)$/$branch-$1-$2/i;
202 } elsif ($filter eq 'EAN13') {
203 my $ean = CheckDigits('ean');
204 if ( $ean->is_valid($barcode) ) {
205 #$barcode = sprintf('%013d',$barcode); # this doesn't work on 32-bit systems
206 $barcode = '0' x ( 13 - length($barcode) ) . $barcode;
208 warn "# [$barcode] not valid EAN-13/UPC-A\n";
211 return $barcode; # return barcode, modified or not
216 $str = &decode($chunk);
218 Decodes a segment of a string emitted by a CueCat barcode scanner and
221 FIXME: Should be replaced with Barcode::Cuecat from CPAN
222 or Javascript based decoding on the client side.
229 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-';
230 my @s = map { index( $seq, $_ ); } split( //, $encoded );
231 my $l = ( $#s + 1 ) % 4;
234 # warn "Error: Cuecat decode parsing failed!";
242 my $n = ( ( $s[0] << 6 | $s[1] ) << 6 | $s[2] ) << 6 | $s[3];
244 chr( ( $n >> 16 ) ^ 67 )
245 .chr( ( $n >> 8 & 255 ) ^ 67 )
246 .chr( ( $n & 255 ) ^ 67 );
249 $r = substr( $r, 0, length($r) - $l );
255 ($dotransfer, $messages, $iteminformation) = &transferbook($newbranch,
256 $barcode, $ignore_reserves, $trigger);
258 Transfers an item to a new branch. If the item is currently on loan, it is automatically returned before the actual transfer.
260 C<$newbranch> is the code for the branch to which the item should be transferred.
262 C<$barcode> is the barcode of the item to be transferred.
264 If C<$ignore_reserves> is true, C<&transferbook> ignores reserves.
265 Otherwise, if an item is reserved, the transfer fails.
267 C<$trigger> is the enum value for what triggered the transfer.
269 Returns three values:
275 is true if the transfer was successful.
279 is a reference-to-hash which may have any of the following keys:
285 There is no item in the catalog with the given barcode. The value is C<$barcode>.
287 =item C<DestinationEqualsHolding>
289 The item is already at the branch to which it is being transferred. The transfer is nonetheless considered to have failed. The value should be ignored.
293 The item was on loan, and C<&transferbook> automatically returned it before transferring it. The value is the borrower number of the patron who had the item.
297 The item was reserved. The value is a reference-to-hash whose keys are fields from the reserves table of the Koha database, and C<biblioitemnumber>. It also has the key C<ResFound>, whose value is either C<Waiting> or C<Reserved>.
299 =item C<WasTransferred>
301 The item was eligible to be transferred. Barring problems communicating with the database, the transfer should indeed have succeeded. The value should be ignored.
310 my ( $tbr, $barcode, $ignoreRs, $trigger ) = @_;
313 my $item = Koha::Items->find( { barcode => $barcode } );
317 $messages->{'BadBarcode'} = $barcode;
319 return ( $dotransfer, $messages );
322 my $itemnumber = $item->itemnumber;
323 # get branches of book...
324 my $hbr = $item->homebranch;
325 my $fbr = $item->holdingbranch;
327 # if using Branch Transfer Limits
328 if ( C4::Context->preference("UseBranchTransferLimits") == 1 ) {
329 my $code = C4::Context->preference("BranchTransferLimitsType") eq 'ccode' ? $item->ccode : $item->biblio->biblioitem->itemtype; # BranchTransferLimitsType is 'ccode' or 'itemtype'
330 if ( C4::Context->preference("item-level_itypes") && C4::Context->preference("BranchTransferLimitsType") eq 'itemtype' ) {
331 if ( ! IsBranchTransferAllowed( $tbr, $fbr, $item->itype ) ) {
332 $messages->{'NotAllowed'} = $tbr . "::" . $item->itype;
335 } elsif ( ! IsBranchTransferAllowed( $tbr, $fbr, $code ) ) {
336 $messages->{'NotAllowed'} = $tbr . "::" . $code;
341 # can't transfer book if is already there....
342 if ( $fbr eq $tbr ) {
343 $messages->{'DestinationEqualsHolding'} = 1;
347 # check if it is still issued to someone, return it...
348 my $issue = Koha::Checkouts->find({ itemnumber => $itemnumber });
350 AddReturn( $barcode, $fbr );
351 $messages->{'WasReturned'} = $issue->borrowernumber;
355 # That'll save a database query.
356 my ( $resfound, $resrec, undef ) =
357 CheckReserves( $itemnumber );
358 if ( $resfound and not $ignoreRs ) {
359 $resrec->{'ResFound'} = $resfound;
360 $messages->{'ResFound'} = $resrec;
364 #actually do the transfer....
366 ModItemTransfer( $itemnumber, $fbr, $tbr, $trigger );
368 # don't need to update MARC anymore, we do it in batch now
369 $messages->{'WasTransfered'} = 1;
372 ModDateLastSeen( $itemnumber );
373 return ( $dotransfer, $messages );
378 my $borrower = shift;
379 my $item_object = shift;
381 my $onsite_checkout = $params->{onsite_checkout} || 0;
382 my $switch_onsite_checkout = $params->{switch_onsite_checkout} || 0;
383 my $cat_borrower = $borrower->{'categorycode'};
384 my $dbh = C4::Context->dbh;
386 # Get which branchcode we need
387 $branch = _GetCircControlBranch($item_object->unblessed,$borrower);
388 my $type = $item_object->effective_itemtype;
390 # given branch, patron category, and item type, determine
391 # applicable issuing rule
392 my $maxissueqty_rule = Koha::CirculationRules->get_effective_rule(
394 categorycode => $cat_borrower,
396 branchcode => $branch,
397 rule_name => 'maxissueqty',
400 my $maxonsiteissueqty_rule = Koha::CirculationRules->get_effective_rule(
402 categorycode => $cat_borrower,
404 branchcode => $branch,
405 rule_name => 'maxonsiteissueqty',
410 # if a rule is found and has a loan limit set, count
411 # how many loans the patron already has that meet that
413 if (defined($maxissueqty_rule) and $maxissueqty_rule->rule_value ne '') {
416 SELECT COUNT(*) AS total, COALESCE(SUM(onsite_checkout), 0) AS onsite_checkouts
418 JOIN items USING (itemnumber)
421 my $rule_itemtype = $maxissueqty_rule->itemtype;
422 unless ($rule_itemtype) {
423 # matching rule has the default item type, so count only
424 # those existing loans that don't fall under a more
426 if (C4::Context->preference('item-level_itypes')) {
427 $count_query .= " WHERE items.itype NOT IN (
428 SELECT itemtype FROM circulation_rules
430 AND (categorycode = ? OR categorycode = ?)
431 AND itemtype IS NOT NULL
432 AND rule_name = 'maxissueqty'
435 $count_query .= " JOIN biblioitems USING (biblionumber)
436 WHERE biblioitems.itemtype NOT IN (
437 SELECT itemtype FROM circulation_rules
439 AND (categorycode = ? OR categorycode = ?)
440 AND itemtype IS NOT NULL
441 AND rule_name = 'maxissueqty'
444 push @bind_params, $maxissueqty_rule->branchcode;
445 push @bind_params, $maxissueqty_rule->categorycode;
446 push @bind_params, $cat_borrower;
448 # rule has specific item type, so count loans of that
450 if (C4::Context->preference('item-level_itypes')) {
451 $count_query .= " WHERE items.itype = ? ";
453 $count_query .= " JOIN biblioitems USING (biblionumber)
454 WHERE biblioitems.itemtype= ? ";
456 push @bind_params, $type;
459 $count_query .= " AND borrowernumber = ? ";
460 push @bind_params, $borrower->{'borrowernumber'};
461 my $rule_branch = $maxissueqty_rule->branchcode;
463 if (C4::Context->preference('CircControl') eq 'PickupLibrary') {
464 $count_query .= " AND issues.branchcode = ? ";
465 push @bind_params, $rule_branch;
466 } elsif (C4::Context->preference('CircControl') eq 'PatronLibrary') {
467 ; # if branch is the patron's home branch, then count all loans by patron
469 $count_query .= " AND items.homebranch = ? ";
470 push @bind_params, $rule_branch;
474 my ( $checkout_count, $onsite_checkout_count ) = $dbh->selectrow_array( $count_query, {}, @bind_params );
476 my $max_checkouts_allowed = $maxissueqty_rule ? $maxissueqty_rule->rule_value : undef;
477 my $max_onsite_checkouts_allowed = $maxonsiteissueqty_rule ? $maxonsiteissueqty_rule->rule_value : undef;
479 if ( $onsite_checkout and $max_onsite_checkouts_allowed ne '' ) {
480 if ( $onsite_checkout_count >= $max_onsite_checkouts_allowed ) {
482 reason => 'TOO_MANY_ONSITE_CHECKOUTS',
483 count => $onsite_checkout_count,
484 max_allowed => $max_onsite_checkouts_allowed,
488 if ( C4::Context->preference('ConsiderOnSiteCheckoutsAsNormalCheckouts') ) {
489 my $delta = $switch_onsite_checkout ? 1 : 0;
490 if ( $checkout_count >= $max_checkouts_allowed + $delta ) {
492 reason => 'TOO_MANY_CHECKOUTS',
493 count => $checkout_count,
494 max_allowed => $max_checkouts_allowed,
497 } elsif ( not $onsite_checkout ) {
498 if ( $checkout_count - $onsite_checkout_count >= $max_checkouts_allowed ) {
500 reason => 'TOO_MANY_CHECKOUTS',
501 count => $checkout_count - $onsite_checkout_count,
502 max_allowed => $max_checkouts_allowed,
508 # Now count total loans against the limit for the branch
509 my $branch_borrower_circ_rule = GetBranchBorrowerCircRule($branch, $cat_borrower);
510 if (defined($branch_borrower_circ_rule->{patron_maxissueqty}) and $branch_borrower_circ_rule->{patron_maxissueqty} ne '') {
511 my @bind_params = ();
512 my $branch_count_query = q|
513 SELECT COUNT(*) AS total, COALESCE(SUM(onsite_checkout), 0) AS onsite_checkouts
515 JOIN items USING (itemnumber)
516 WHERE borrowernumber = ?
518 push @bind_params, $borrower->{borrowernumber};
520 if (C4::Context->preference('CircControl') eq 'PickupLibrary') {
521 $branch_count_query .= " AND issues.branchcode = ? ";
522 push @bind_params, $branch;
523 } elsif (C4::Context->preference('CircControl') eq 'PatronLibrary') {
524 ; # if branch is the patron's home branch, then count all loans by patron
526 $branch_count_query .= " AND items.homebranch = ? ";
527 push @bind_params, $branch;
529 my ( $checkout_count, $onsite_checkout_count ) = $dbh->selectrow_array( $branch_count_query, {}, @bind_params );
530 my $max_checkouts_allowed = $branch_borrower_circ_rule->{patron_maxissueqty};
531 my $max_onsite_checkouts_allowed = $branch_borrower_circ_rule->{patron_maxonsiteissueqty};
533 if ( $onsite_checkout and $max_onsite_checkouts_allowed ne '' ) {
534 if ( $onsite_checkout_count >= $max_onsite_checkouts_allowed ) {
536 reason => 'TOO_MANY_ONSITE_CHECKOUTS',
537 count => $onsite_checkout_count,
538 max_allowed => $max_onsite_checkouts_allowed,
542 if ( C4::Context->preference('ConsiderOnSiteCheckoutsAsNormalCheckouts') ) {
543 my $delta = $switch_onsite_checkout ? 1 : 0;
544 if ( $checkout_count >= $max_checkouts_allowed + $delta ) {
546 reason => 'TOO_MANY_CHECKOUTS',
547 count => $checkout_count,
548 max_allowed => $max_checkouts_allowed,
551 } elsif ( not $onsite_checkout ) {
552 if ( $checkout_count - $onsite_checkout_count >= $max_checkouts_allowed ) {
554 reason => 'TOO_MANY_CHECKOUTS',
555 count => $checkout_count - $onsite_checkout_count,
556 max_allowed => $max_checkouts_allowed,
562 if ( not defined( $maxissueqty_rule ) and not defined($branch_borrower_circ_rule->{patron_maxissueqty}) ) {
563 return { reason => 'NO_RULE_DEFINED', max_allowed => 0 };
566 # OK, the patron can issue !!!
570 =head2 CanBookBeIssued
572 ( $issuingimpossible, $needsconfirmation, [ $alerts ] ) = CanBookBeIssued( $patron,
573 $barcode, $duedate, $inprocess, $ignore_reserves, $params );
575 Check if a book can be issued.
577 C<$issuingimpossible> and C<$needsconfirmation> are hashrefs.
579 IMPORTANT: The assumption by users of this routine is that causes blocking
580 the issue are keyed by uppercase labels and other returned
581 data is keyed in lower case!
585 =item C<$patron> is a Koha::Patron
587 =item C<$barcode> is the bar code of the book being issued.
589 =item C<$duedates> is a DateTime object.
591 =item C<$inprocess> boolean switch
593 =item C<$ignore_reserves> boolean switch
595 =item C<$params> Hashref of additional parameters
598 override_high_holds - Ignore high holds
599 onsite_checkout - Checkout is an onsite checkout that will not leave the library
607 =item C<$issuingimpossible> a reference to a hash. It contains reasons why issuing is impossible.
608 Possible values are :
614 sticky due date is invalid
618 borrower gone with no address
622 borrower declared it's card lost
628 =head3 UNKNOWN_BARCODE
642 item is restricted (set by ??)
644 C<$needsconfirmation> a reference to a hash. It contains reasons why the loan
645 could be prevented, but ones that can be overriden by the operator.
647 Possible values are :
655 renewing, not issuing
657 =head3 ISSUED_TO_ANOTHER
659 issued to someone else.
663 reserved for someone else.
667 sticky due date is invalid or due date in the past
671 if the borrower borrows to much things
675 sub CanBookBeIssued {
676 my ( $patron, $barcode, $duedate, $inprocess, $ignore_reserves, $params ) = @_;
677 my %needsconfirmation; # filled with problems that needs confirmations
678 my %issuingimpossible; # filled with problems that causes the issue to be IMPOSSIBLE
679 my %alerts; # filled with messages that shouldn't stop issuing, but the librarian should be aware of.
680 my %messages; # filled with information messages that should be displayed.
682 my $onsite_checkout = $params->{onsite_checkout} || 0;
683 my $override_high_holds = $params->{override_high_holds} || 0;
685 my $item_object = Koha::Items->find({barcode => $barcode });
687 # MANDATORY CHECKS - unless item exists, nothing else matters
688 unless ( $item_object ) {
689 $issuingimpossible{UNKNOWN_BARCODE} = 1;
691 return ( \%issuingimpossible, \%needsconfirmation ) if %issuingimpossible;
693 my $item_unblessed = $item_object->unblessed; # Transition...
694 my $issue = $item_object->checkout;
695 my $biblio = $item_object->biblio;
697 my $biblioitem = $biblio->biblioitem;
698 my $effective_itemtype = $item_object->effective_itemtype;
699 my $dbh = C4::Context->dbh;
700 my $patron_unblessed = $patron->unblessed;
702 my $circ_library = Koha::Libraries->find( _GetCircControlBranch($item_unblessed, $patron_unblessed) );
704 # DUE DATE is OK ? -- should already have checked.
706 if ($duedate && ref $duedate ne 'DateTime') {
707 $duedate = dt_from_string($duedate);
709 my $now = dt_from_string();
710 unless ( $duedate ) {
711 my $issuedate = $now->clone();
713 $duedate = CalcDateDue( $issuedate, $effective_itemtype, $circ_library->branchcode, $patron_unblessed );
715 # Offline circ calls AddIssue directly, doesn't run through here
716 # So issuingimpossible should be ok.
719 my $fees = Koha::Charges::Fees->new(
722 library => $circ_library,
723 item => $item_object,
729 my $today = $now->clone();
730 $today->truncate( to => 'minute');
731 if (DateTime->compare($duedate,$today) == -1 ) { # duedate cannot be before now
732 $needsconfirmation{INVALID_DATE} = output_pref($duedate);
735 $issuingimpossible{INVALID_DATE} = output_pref($duedate);
741 if ( $patron->category->category_type eq 'X' && ( $item_object->barcode )) {
742 # stats only borrower -- add entry to statistics table, and return issuingimpossible{STATS} = 1 .
744 branch => C4::Context->userenv->{'branch'},
746 itemnumber => $item_object->itemnumber,
747 itemtype => $effective_itemtype,
748 borrowernumber => $patron->borrowernumber,
749 ccode => $item_object->ccode}
751 ModDateLastSeen( $item_object->itemnumber ); # FIXME Move to Koha::Item
752 return( { STATS => 1 }, {});
755 if ( $patron->gonenoaddress && $patron->gonenoaddress == 1 ) {
756 $issuingimpossible{GNA} = 1;
759 if ( $patron->lost && $patron->lost == 1 ) {
760 $issuingimpossible{CARD_LOST} = 1;
762 if ( $patron->is_debarred ) {
763 $issuingimpossible{DEBARRED} = 1;
766 if ( $patron->is_expired ) {
767 $issuingimpossible{EXPIRED} = 1;
775 my $account = $patron->account;
776 my $balance = $account->balance;
777 my $non_issues_charges = $account->non_issues_charges;
778 my $other_charges = $balance - $non_issues_charges;
780 my $amountlimit = C4::Context->preference("noissuescharge");
781 my $allowfineoverride = C4::Context->preference("AllowFineOverride");
782 my $allfinesneedoverride = C4::Context->preference("AllFinesNeedOverride");
784 # Check the debt of this patrons guarantees
785 my $no_issues_charge_guarantees = C4::Context->preference("NoIssuesChargeGuarantees");
786 $no_issues_charge_guarantees = undef unless looks_like_number( $no_issues_charge_guarantees );
787 if ( defined $no_issues_charge_guarantees ) {
788 my @guarantees = map { $_->guarantee } $patron->guarantee_relationships();
789 my $guarantees_non_issues_charges;
790 foreach my $g ( @guarantees ) {
791 $guarantees_non_issues_charges += $g->account->non_issues_charges;
794 if ( $guarantees_non_issues_charges > $no_issues_charge_guarantees && !$inprocess && !$allowfineoverride) {
795 $issuingimpossible{DEBT_GUARANTEES} = $guarantees_non_issues_charges;
796 } elsif ( $guarantees_non_issues_charges > $no_issues_charge_guarantees && !$inprocess && $allowfineoverride) {
797 $needsconfirmation{DEBT_GUARANTEES} = $guarantees_non_issues_charges;
798 } elsif ( $allfinesneedoverride && $guarantees_non_issues_charges > 0 && $guarantees_non_issues_charges <= $no_issues_charge_guarantees && !$inprocess ) {
799 $needsconfirmation{DEBT_GUARANTEES} = $guarantees_non_issues_charges;
803 if ( C4::Context->preference("IssuingInProcess") ) {
804 if ( $non_issues_charges > $amountlimit && !$inprocess && !$allowfineoverride) {
805 $issuingimpossible{DEBT} = $non_issues_charges;
806 } elsif ( $non_issues_charges > $amountlimit && !$inprocess && $allowfineoverride) {
807 $needsconfirmation{DEBT} = $non_issues_charges;
808 } elsif ( $allfinesneedoverride && $non_issues_charges > 0 && $non_issues_charges <= $amountlimit && !$inprocess ) {
809 $needsconfirmation{DEBT} = $non_issues_charges;
813 if ( $non_issues_charges > $amountlimit && $allowfineoverride ) {
814 $needsconfirmation{DEBT} = $non_issues_charges;
815 } elsif ( $non_issues_charges > $amountlimit && !$allowfineoverride) {
816 $issuingimpossible{DEBT} = $non_issues_charges;
817 } elsif ( $non_issues_charges > 0 && $allfinesneedoverride ) {
818 $needsconfirmation{DEBT} = $non_issues_charges;
822 if ($balance > 0 && $other_charges > 0) {
823 $alerts{OTHER_CHARGES} = sprintf( "%.2f", $other_charges );
826 $patron = Koha::Patrons->find( $patron->borrowernumber ); # FIXME Refetch just in case, to avoid regressions. But must not be needed
827 $patron_unblessed = $patron->unblessed;
829 if ( my $debarred_date = $patron->is_debarred ) {
830 # patron has accrued fine days or has a restriction. $count is a date
831 if ($debarred_date eq '9999-12-31') {
832 $issuingimpossible{USERBLOCKEDNOENDDATE} = $debarred_date;
835 $issuingimpossible{USERBLOCKEDWITHENDDATE} = $debarred_date;
837 } elsif ( my $num_overdues = $patron->has_overdues ) {
838 ## patron has outstanding overdue loans
839 if ( C4::Context->preference("OverduesBlockCirc") eq 'block'){
840 $issuingimpossible{USERBLOCKEDOVERDUE} = $num_overdues;
842 elsif ( C4::Context->preference("OverduesBlockCirc") eq 'confirmation'){
843 $needsconfirmation{USERBLOCKEDOVERDUE} = $num_overdues;
848 # CHECK IF BOOK ALREADY ISSUED TO THIS BORROWER
850 if ( $issue && $issue->borrowernumber eq $patron->borrowernumber ){
852 # Already issued to current borrower.
853 # If it is an on-site checkout if it can be switched to a normal checkout
854 # or ask whether the loan should be renewed
856 if ( $issue->onsite_checkout
857 and C4::Context->preference('SwitchOnSiteCheckouts') ) {
858 $messages{ONSITE_CHECKOUT_WILL_BE_SWITCHED} = 1;
860 my ($CanBookBeRenewed,$renewerror) = CanBookBeRenewed(
861 $patron->borrowernumber,
862 $item_object->itemnumber,
864 if ( $CanBookBeRenewed == 0 ) { # no more renewals allowed
865 if ( $renewerror eq 'onsite_checkout' ) {
866 $issuingimpossible{NO_RENEWAL_FOR_ONSITE_CHECKOUTS} = 1;
869 $issuingimpossible{NO_MORE_RENEWALS} = 1;
873 $needsconfirmation{RENEW_ISSUE} = 1;
879 # issued to someone else
881 my $patron = Koha::Patrons->find( $issue->borrowernumber );
883 my ( $can_be_returned, $message ) = CanBookBeReturned( $item_unblessed, C4::Context->userenv->{branch} );
885 unless ( $can_be_returned ) {
886 $issuingimpossible{RETURN_IMPOSSIBLE} = 1;
887 $issuingimpossible{branch_to_return} = $message;
889 if ( C4::Context->preference('AutoReturnCheckedOutItems') ) {
890 $alerts{RETURNED_FROM_ANOTHER} = { patron => $patron };
892 $needsconfirmation{ISSUED_TO_ANOTHER} = 1;
893 $needsconfirmation{issued_firstname} = $patron->firstname;
894 $needsconfirmation{issued_surname} = $patron->surname;
895 $needsconfirmation{issued_cardnumber} = $patron->cardnumber;
896 $needsconfirmation{issued_borrowernumber} = $patron->borrowernumber;
901 # JB34 CHECKS IF BORROWERS DON'T HAVE ISSUE TOO MANY BOOKS
903 my $switch_onsite_checkout = (
904 C4::Context->preference('SwitchOnSiteCheckouts')
906 and $issue->onsite_checkout
907 and $issue->borrowernumber == $patron->borrowernumber ? 1 : 0 );
908 my $toomany = TooMany( $patron_unblessed, $item_object, { onsite_checkout => $onsite_checkout, switch_onsite_checkout => $switch_onsite_checkout, } );
909 # if TooMany max_allowed returns 0 the user doesn't have permission to check out this book
910 if ( $toomany && not exists $needsconfirmation{RENEW_ISSUE} ) {
911 if ( $toomany->{max_allowed} == 0 ) {
912 $needsconfirmation{PATRON_CANT} = 1;
914 if ( C4::Context->preference("AllowTooManyOverride") ) {
915 $needsconfirmation{TOO_MANY} = $toomany->{reason};
916 $needsconfirmation{current_loan_count} = $toomany->{count};
917 $needsconfirmation{max_loans_allowed} = $toomany->{max_allowed};
919 $issuingimpossible{TOO_MANY} = $toomany->{reason};
920 $issuingimpossible{current_loan_count} = $toomany->{count};
921 $issuingimpossible{max_loans_allowed} = $toomany->{max_allowed};
926 # CHECKPREVCHECKOUT: CHECK IF ITEM HAS EVER BEEN LENT TO PATRON
928 $patron = Koha::Patrons->find( $patron->borrowernumber ); # FIXME Refetch just in case, to avoid regressions. But must not be needed
929 my $wants_check = $patron->wants_check_for_previous_checkout;
930 $needsconfirmation{PREVISSUE} = 1
931 if ($wants_check and $patron->do_check_for_previous_checkout($item_unblessed));
936 if ( $item_object->notforloan )
938 if(!C4::Context->preference("AllowNotForLoanOverride")){
939 $issuingimpossible{NOT_FOR_LOAN} = 1;
940 $issuingimpossible{item_notforloan} = $item_object->notforloan;
942 $needsconfirmation{NOT_FOR_LOAN_FORCING} = 1;
943 $needsconfirmation{item_notforloan} = $item_object->notforloan;
947 # we have to check itemtypes.notforloan also
948 if (C4::Context->preference('item-level_itypes')){
949 # this should probably be a subroutine
950 my $sth = $dbh->prepare("SELECT notforloan FROM itemtypes WHERE itemtype = ?");
951 $sth->execute($effective_itemtype);
952 my $notforloan=$sth->fetchrow_hashref();
953 if ($notforloan->{'notforloan'}) {
954 if (!C4::Context->preference("AllowNotForLoanOverride")) {
955 $issuingimpossible{NOT_FOR_LOAN} = 1;
956 $issuingimpossible{itemtype_notforloan} = $effective_itemtype;
958 $needsconfirmation{NOT_FOR_LOAN_FORCING} = 1;
959 $needsconfirmation{itemtype_notforloan} = $effective_itemtype;
964 my $itemtype = Koha::ItemTypes->find($biblioitem->itemtype);
965 if ( $itemtype && defined $itemtype->notforloan && $itemtype->notforloan == 1){
966 if (!C4::Context->preference("AllowNotForLoanOverride")) {
967 $issuingimpossible{NOT_FOR_LOAN} = 1;
968 $issuingimpossible{itemtype_notforloan} = $effective_itemtype;
970 $needsconfirmation{NOT_FOR_LOAN_FORCING} = 1;
971 $needsconfirmation{itemtype_notforloan} = $effective_itemtype;
976 if ( $item_object->withdrawn && $item_object->withdrawn > 0 )
978 $issuingimpossible{WTHDRAWN} = 1;
980 if ( $item_object->restricted
981 && $item_object->restricted == 1 )
983 $issuingimpossible{RESTRICTED} = 1;
985 if ( $item_object->itemlost && C4::Context->preference("IssueLostItem") ne 'nothing' ) {
986 my $av = Koha::AuthorisedValues->search({ category => 'LOST', authorised_value => $item_object->itemlost });
987 my $code = $av->count ? $av->next->lib : '';
988 $needsconfirmation{ITEM_LOST} = $code if ( C4::Context->preference("IssueLostItem") eq 'confirm' );
989 $alerts{ITEM_LOST} = $code if ( C4::Context->preference("IssueLostItem") eq 'alert' );
991 if ( C4::Context->preference("IndependentBranches") ) {
992 my $userenv = C4::Context->userenv;
993 unless ( C4::Context->IsSuperLibrarian() ) {
994 my $HomeOrHoldingBranch = C4::Context->preference("HomeOrHoldingBranch");
995 if ( $item_object->$HomeOrHoldingBranch ne $userenv->{branch} ){
996 $issuingimpossible{ITEMNOTSAMEBRANCH} = 1;
997 $issuingimpossible{'itemhomebranch'} = $item_object->$HomeOrHoldingBranch;
999 $needsconfirmation{BORRNOTSAMEBRANCH} = $patron->branchcode
1000 if ( $patron->branchcode ne $userenv->{branch} );
1005 # CHECK IF THERE IS RENTAL CHARGES. RENTAL MUST BE CONFIRMED BY THE BORROWER
1007 my $rentalConfirmation = C4::Context->preference("RentalFeesCheckoutConfirmation");
1008 if ($rentalConfirmation) {
1009 my ($rentalCharge) = GetIssuingCharges( $item_object->itemnumber, $patron->borrowernumber );
1011 my $itemtype_object = Koha::ItemTypes->find( $item_object->effective_itemtype );
1012 if ($itemtype_object) {
1013 my $accumulate_charge = $fees->accumulate_rentalcharge();
1014 if ( $accumulate_charge > 0 ) {
1015 $rentalCharge += $accumulate_charge;
1019 if ( $rentalCharge > 0 ) {
1020 $needsconfirmation{RENTALCHARGE} = $rentalCharge;
1024 unless ( $ignore_reserves ) {
1025 # See if the item is on reserve.
1026 my ( $restype, $res ) = C4::Reserves::CheckReserves( $item_object->itemnumber );
1028 my $resbor = $res->{'borrowernumber'};
1029 if ( $resbor ne $patron->borrowernumber ) {
1030 my $patron = Koha::Patrons->find( $resbor );
1031 if ( $restype eq "Waiting" )
1033 # The item is on reserve and waiting, but has been
1034 # reserved by some other patron.
1035 $needsconfirmation{RESERVE_WAITING} = 1;
1036 $needsconfirmation{'resfirstname'} = $patron->firstname;
1037 $needsconfirmation{'ressurname'} = $patron->surname;
1038 $needsconfirmation{'rescardnumber'} = $patron->cardnumber;
1039 $needsconfirmation{'resborrowernumber'} = $patron->borrowernumber;
1040 $needsconfirmation{'resbranchcode'} = $res->{branchcode};
1041 $needsconfirmation{'reswaitingdate'} = $res->{'waitingdate'};
1042 $needsconfirmation{'reserve_id'} = $res->{reserve_id};
1044 elsif ( $restype eq "Reserved" ) {
1045 # The item is on reserve for someone else.
1046 $needsconfirmation{RESERVED} = 1;
1047 $needsconfirmation{'resfirstname'} = $patron->firstname;
1048 $needsconfirmation{'ressurname'} = $patron->surname;
1049 $needsconfirmation{'rescardnumber'} = $patron->cardnumber;
1050 $needsconfirmation{'resborrowernumber'} = $patron->borrowernumber;
1051 $needsconfirmation{'resbranchcode'} = $patron->branchcode;
1052 $needsconfirmation{'resreservedate'} = $res->{reservedate};
1053 $needsconfirmation{'reserve_id'} = $res->{reserve_id};
1059 ## CHECK AGE RESTRICTION
1060 my $agerestriction = $biblioitem->agerestriction;
1061 my ($restriction_age, $daysToAgeRestriction) = GetAgeRestriction( $agerestriction, $patron->unblessed );
1062 if ( $daysToAgeRestriction && $daysToAgeRestriction > 0 ) {
1063 if ( C4::Context->preference('AgeRestrictionOverride') ) {
1064 $needsconfirmation{AGE_RESTRICTION} = "$agerestriction";
1067 $issuingimpossible{AGE_RESTRICTION} = "$agerestriction";
1071 ## check for high holds decreasing loan period
1072 if ( C4::Context->preference('decreaseLoanHighHolds') ) {
1073 my $check = checkHighHolds( $item_unblessed, $patron_unblessed );
1075 if ( $check->{exceeded} ) {
1076 if ($override_high_holds) {
1077 $alerts{HIGHHOLDS} = {
1078 num_holds => $check->{outstanding},
1079 duration => $check->{duration},
1080 returndate => output_pref( { dt => dt_from_string($check->{due_date}), dateformat => 'iso', timeformat => '24hr' }),
1084 $needsconfirmation{HIGHHOLDS} = {
1085 num_holds => $check->{outstanding},
1086 duration => $check->{duration},
1087 returndate => output_pref( { dt => dt_from_string($check->{due_date}), dateformat => 'iso', timeformat => '24hr' }),
1094 !C4::Context->preference('AllowMultipleIssuesOnABiblio') &&
1095 # don't do the multiple loans per bib check if we've
1096 # already determined that we've got a loan on the same item
1097 !$issuingimpossible{NO_MORE_RENEWALS} &&
1098 !$needsconfirmation{RENEW_ISSUE}
1100 # Check if borrower has already issued an item from the same biblio
1101 # Only if it's not a subscription
1102 my $biblionumber = $item_object->biblionumber;
1103 require C4::Serials;
1104 my $is_a_subscription = C4::Serials::CountSubscriptionFromBiblionumber($biblionumber);
1105 unless ($is_a_subscription) {
1106 # FIXME Should be $patron->checkouts($args);
1107 my $checkouts = Koha::Checkouts->search(
1109 borrowernumber => $patron->borrowernumber,
1110 biblionumber => $biblionumber,
1116 # if we get here, we don't already have a loan on this item,
1117 # so if there are any loans on this bib, ask for confirmation
1118 if ( $checkouts->count ) {
1119 $needsconfirmation{BIBLIO_ALREADY_ISSUED} = 1;
1124 return ( \%issuingimpossible, \%needsconfirmation, \%alerts, \%messages, );
1127 =head2 CanBookBeReturned
1129 ($returnallowed, $message) = CanBookBeReturned($item, $branch)
1131 Check whether the item can be returned to the provided branch
1135 =item C<$item> is a hash of item information as returned Koha::Items->find->unblessed (Temporary, should be a Koha::Item instead)
1137 =item C<$branch> is the branchcode where the return is taking place
1145 =item C<$returnallowed> is 0 or 1, corresponding to whether the return is allowed (1) or not (0)
1147 =item C<$message> is the branchcode where the item SHOULD be returned, if the return is not allowed
1153 sub CanBookBeReturned {
1154 my ($item, $branch) = @_;
1155 my $allowreturntobranch = C4::Context->preference("AllowReturnToBranch") || 'anywhere';
1157 # assume return is allowed to start
1161 # identify all cases where return is forbidden
1162 if ($allowreturntobranch eq 'homebranch' && $branch ne $item->{'homebranch'}) {
1164 $message = $item->{'homebranch'};
1165 } elsif ($allowreturntobranch eq 'holdingbranch' && $branch ne $item->{'holdingbranch'}) {
1167 $message = $item->{'holdingbranch'};
1168 } elsif ($allowreturntobranch eq 'homeorholdingbranch' && $branch ne $item->{'homebranch'} && $branch ne $item->{'holdingbranch'}) {
1170 $message = $item->{'homebranch'}; # FIXME: choice of homebranch is arbitrary
1173 return ($allowed, $message);
1176 =head2 CheckHighHolds
1178 used when syspref decreaseLoanHighHolds is active. Returns 1 or 0 to define whether the minimum value held in
1179 decreaseLoanHighHoldsValue is exceeded, the total number of outstanding holds, the number of days the loan
1180 has been decreased to (held in syspref decreaseLoanHighHoldsValue), and the new due date
1184 sub checkHighHolds {
1185 my ( $item, $borrower ) = @_;
1186 my $branchcode = _GetCircControlBranch( $item, $borrower );
1187 my $item_object = Koha::Items->find( $item->{itemnumber} );
1196 my $holds = Koha::Holds->search( { biblionumber => $item->{'biblionumber'} } );
1198 if ( $holds->count() ) {
1199 $return_data->{outstanding} = $holds->count();
1201 my $decreaseLoanHighHoldsControl = C4::Context->preference('decreaseLoanHighHoldsControl');
1202 my $decreaseLoanHighHoldsValue = C4::Context->preference('decreaseLoanHighHoldsValue');
1203 my $decreaseLoanHighHoldsIgnoreStatuses = C4::Context->preference('decreaseLoanHighHoldsIgnoreStatuses');
1205 my @decreaseLoanHighHoldsIgnoreStatuses = split( /,/, $decreaseLoanHighHoldsIgnoreStatuses );
1207 if ( $decreaseLoanHighHoldsControl eq 'static' ) {
1209 # static means just more than a given number of holds on the record
1211 # If the number of holds is less than the threshold, we can stop here
1212 if ( $holds->count() < $decreaseLoanHighHoldsValue ) {
1213 return $return_data;
1216 elsif ( $decreaseLoanHighHoldsControl eq 'dynamic' ) {
1218 # dynamic means X more than the number of holdable items on the record
1220 # let's get the items
1221 my @items = $holds->next()->biblio()->items()->as_list;
1223 # Remove any items with status defined to be ignored even if the would not make item unholdable
1224 foreach my $status (@decreaseLoanHighHoldsIgnoreStatuses) {
1225 @items = grep { !$_->$status } @items;
1228 # Remove any items that are not holdable for this patron
1229 @items = grep { CanItemBeReserved( $borrower->{borrowernumber}, $_->itemnumber, undef, { ignore_found_holds => 1 } )->{status} eq 'OK' } @items;
1231 my $items_count = scalar @items;
1233 my $threshold = $items_count + $decreaseLoanHighHoldsValue;
1235 # If the number of holds is less than the count of items we have
1236 # plus the number of holds allowed above that count, we can stop here
1237 if ( $holds->count() <= $threshold ) {
1238 return $return_data;
1242 my $issuedate = dt_from_string();
1244 my $itype = $item_object->effective_itemtype;
1245 my $daysmode = Koha::CirculationRules->get_effective_daysmode(
1247 categorycode => $borrower->{categorycode},
1249 branchcode => $branchcode,
1252 my $calendar = Koha::Calendar->new( branchcode => $branchcode, days_mode => $daysmode );
1254 my $orig_due = C4::Circulation::CalcDateDue( $issuedate, $itype, $branchcode, $borrower );
1256 my $decreaseLoanHighHoldsDuration = C4::Context->preference('decreaseLoanHighHoldsDuration');
1258 my $reduced_datedue = $calendar->addDate( $issuedate, $decreaseLoanHighHoldsDuration );
1259 $reduced_datedue->set_hour($orig_due->hour);
1260 $reduced_datedue->set_minute($orig_due->minute);
1261 $reduced_datedue->truncate( to => 'minute' );
1263 if ( DateTime->compare( $reduced_datedue, $orig_due ) == -1 ) {
1264 $return_data->{exceeded} = 1;
1265 $return_data->{duration} = $decreaseLoanHighHoldsDuration;
1266 $return_data->{due_date} = $reduced_datedue;
1270 return $return_data;
1275 &AddIssue($borrower, $barcode, [$datedue], [$cancelreserve], [$issuedate])
1277 Issue a book. Does no check, they are done in CanBookBeIssued. If we reach this sub, it means the user confirmed if needed.
1281 =item C<$borrower> is a hash with borrower informations (from Koha::Patron->unblessed).
1283 =item C<$barcode> is the barcode of the item being issued.
1285 =item C<$datedue> is a DateTime object for the max date of return, i.e. the date due (optional).
1286 Calculated if empty.
1288 =item C<$cancelreserve> is 1 to override and cancel any pending reserves for the item (optional).
1290 =item C<$issuedate> is the date to issue the item in iso (YYYY-MM-DD) format (optional).
1291 Defaults to today. Unlike C<$datedue>, NOT a DateTime object, unfortunately.
1293 AddIssue does the following things :
1295 - step 01: check that there is a borrowernumber & a barcode provided
1296 - check for RENEWAL (book issued & being issued to the same patron)
1297 - renewal YES = Calculate Charge & renew
1299 * BOOK ACTUALLY ISSUED ? do a return if book is actually issued (but to someone else)
1301 - fill reserve if reserve to this patron
1302 - cancel reserve or not, otherwise
1303 * TRANSFERT PENDING ?
1304 - complete the transfert
1312 my ( $borrower, $barcode, $datedue, $cancelreserve, $issuedate, $sipmode, $params ) = @_;
1314 my $onsite_checkout = $params && $params->{onsite_checkout} ? 1 : 0;
1315 my $switch_onsite_checkout = $params && $params->{switch_onsite_checkout};
1316 my $auto_renew = $params && $params->{auto_renew};
1317 my $dbh = C4::Context->dbh;
1318 my $barcodecheck = CheckValidBarcode($barcode);
1322 if ( $datedue && ref $datedue ne 'DateTime' ) {
1323 $datedue = dt_from_string($datedue);
1326 # $issuedate defaults to today.
1327 if ( !defined $issuedate ) {
1328 $issuedate = dt_from_string();
1331 if ( ref $issuedate ne 'DateTime' ) {
1332 $issuedate = dt_from_string($issuedate);
1337 # Stop here if the patron or barcode doesn't exist
1338 if ( $borrower && $barcode && $barcodecheck ) {
1339 # find which item we issue
1340 my $item_object = Koha::Items->find({ barcode => $barcode })
1341 or return; # if we don't get an Item, abort.
1342 my $item_unblessed = $item_object->unblessed;
1344 my $branchcode = _GetCircControlBranch( $item_unblessed, $borrower );
1346 # get actual issuing if there is one
1347 my $actualissue = $item_object->checkout;
1349 # check if we just renew the issue.
1350 if ( $actualissue and $actualissue->borrowernumber eq $borrower->{'borrowernumber'}
1351 and not $switch_onsite_checkout ) {
1352 $datedue = AddRenewal(
1353 $borrower->{'borrowernumber'},
1354 $item_object->itemnumber,
1357 $issuedate, # here interpreted as the renewal date
1362 my $itype = $item_object->effective_itemtype;
1363 $datedue = CalcDateDue( $issuedate, $itype, $branchcode, $borrower );
1366 $datedue->truncate( to => 'minute' );
1368 my $patron = Koha::Patrons->find( $borrower );
1369 my $library = Koha::Libraries->find( $branchcode );
1370 my $fees = Koha::Charges::Fees->new(
1373 library => $library,
1374 item => $item_object,
1375 to_date => $datedue,
1379 # it's NOT a renewal
1380 if ( $actualissue and not $switch_onsite_checkout ) {
1381 # This book is currently on loan, but not to the person
1382 # who wants to borrow it now. mark it returned before issuing to the new borrower
1383 my ( $allowed, $message ) = CanBookBeReturned( $item_unblessed, C4::Context->userenv->{branch} );
1384 return unless $allowed;
1385 AddReturn( $item_object->barcode, C4::Context->userenv->{'branch'} );
1388 C4::Reserves::MoveReserve( $item_object->itemnumber, $borrower->{'borrowernumber'}, $cancelreserve );
1390 # Starting process for transfer job (checking transfert and validate it if we have one)
1391 my ($datesent) = GetTransfers( $item_object->itemnumber );
1393 # updating line of branchtranfert to finish it, and changing the to branch value, implement a comment for visibility of this case (maybe for stats ....)
1394 my $sth = $dbh->prepare(
1395 "UPDATE branchtransfers
1396 SET datearrived = now(),
1398 comments = 'Forced branchtransfer'
1399 WHERE itemnumber= ? AND datearrived IS NULL"
1401 $sth->execute( C4::Context->userenv->{'branch'},
1402 $item_object->itemnumber );
1405 # If automatic renewal wasn't selected while issuing, set the value according to the issuing rule.
1406 unless ($auto_renew) {
1407 my $rule = Koha::CirculationRules->get_effective_rule(
1409 categorycode => $borrower->{categorycode},
1410 itemtype => $item_object->effective_itemtype,
1411 branchcode => $branchcode,
1412 rule_name => 'auto_renew'
1416 $auto_renew = $rule->rule_value if $rule;
1419 # Record in the database the fact that the book was issued.
1421 my $itype = $item_object->effective_itemtype;
1422 $datedue = CalcDateDue( $issuedate, $itype, $branchcode, $borrower );
1425 $datedue->truncate( to => 'minute' );
1427 my $issue_attributes = {
1428 borrowernumber => $borrower->{'borrowernumber'},
1429 issuedate => $issuedate->strftime('%Y-%m-%d %H:%M:%S'),
1430 date_due => $datedue->strftime('%Y-%m-%d %H:%M:%S'),
1431 branchcode => C4::Context->userenv->{'branch'},
1432 onsite_checkout => $onsite_checkout,
1433 auto_renew => $auto_renew ? 1 : 0,
1436 $issue = Koha::Checkouts->find( { itemnumber => $item_object->itemnumber } );
1438 $issue->set($issue_attributes)->store;
1441 $issue = Koha::Checkout->new(
1443 itemnumber => $item_object->itemnumber,
1448 if ( $item_object->location && $item_object->location eq 'CART'
1449 && ( !$item_object->permanent_location || $item_object->permanent_location ne 'CART' ) ) {
1450 ## Item was moved to cart via UpdateItemLocationOnCheckin, anything issued should be taken off the cart.
1451 CartToShelf( $item_object->itemnumber );
1454 if ( C4::Context->preference('UpdateTotalIssuesOnCirc') ) {
1455 UpdateTotalIssues( $item_object->biblionumber, 1 );
1458 ## If item was lost, it has now been found, reverse any list item charges if necessary.
1459 if ( $item_object->itemlost ) {
1461 my $no_refund_after_days = C4::Context->preference('NoRefundOnLostReturnedItemsAge');
1462 if ($no_refund_after_days) {
1463 my $today = dt_from_string();
1464 my $lost_age_in_days =
1465 dt_from_string( $item_object->itemlost_on )
1466 ->delta_days($today)
1469 $refund = 0 unless ( $lost_age_in_days < $no_refund_after_days );
1474 && Koha::RefundLostItemFeeRules->should_refund(
1476 current_branch => C4::Context->userenv->{branch},
1477 item_home_branch => $item_object->homebranch,
1478 item_holding_branch => $item_object->holdingbranch,
1483 _FixAccountForLostAndFound( $item_object->itemnumber, undef,
1484 $item_object->barcode );
1488 $item_object->issues( ( $item_object->issues || 0 ) + 1);
1489 $item_object->holdingbranch(C4::Context->userenv->{'branch'});
1490 $item_object->itemlost(0);
1491 $item_object->onloan($datedue->ymd());
1492 $item_object->datelastborrowed( dt_from_string()->ymd() );
1493 $item_object->store({log_action => 0});
1494 ModDateLastSeen( $item_object->itemnumber );
1496 # If it costs to borrow this book, charge it to the patron's account.
1497 my ( $charge, $itemtype ) = GetIssuingCharges( $item_object->itemnumber, $borrower->{'borrowernumber'} );
1498 if ( $charge && $charge > 0 ) {
1499 AddIssuingCharge( $issue, $charge, 'RENT' );
1502 my $itemtype_object = Koha::ItemTypes->find( $item_object->effective_itemtype );
1503 if ( $itemtype_object ) {
1504 my $accumulate_charge = $fees->accumulate_rentalcharge();
1505 if ( $accumulate_charge > 0 ) {
1506 AddIssuingCharge( $issue, $accumulate_charge, 'RENT_DAILY' );
1507 $charge += $accumulate_charge;
1508 $item_unblessed->{charge} = $charge;
1512 _after_circ_actions(
1514 action => 'checkout',
1516 type => ( $onsite_checkout ? 'onsite_checkout' : 'issue' ),
1517 library_id => C4::Context->userenv->{'branch'},
1519 item_id => $item_object->itemnumber,
1520 item_type => $item_object->effective_itemtype,
1521 shelving_location => $item_object->location // q{},
1522 patron_id => $borrower->{'borrowernumber'},
1523 collection_code => $item_object->ccode // q{},
1524 date_due => $datedue
1527 ) if C4::Context->config("enable_plugins");
1529 # Record the fact that this book was issued.
1532 branch => C4::Context->userenv->{'branch'},
1533 type => ( $onsite_checkout ? 'onsite_checkout' : 'issue' ),
1535 other => ( $sipmode ? "SIP-$sipmode" : '' ),
1536 itemnumber => $item_object->itemnumber,
1537 itemtype => $item_object->effective_itemtype,
1538 location => $item_object->location,
1539 borrowernumber => $borrower->{'borrowernumber'},
1540 ccode => $item_object->ccode,
1544 # Send a checkout slip.
1545 my $circulation_alert = 'C4::ItemCirculationAlertPreference';
1547 branchcode => $branchcode,
1548 categorycode => $borrower->{categorycode},
1549 item_type => $item_object->effective_itemtype,
1550 notification => 'CHECKOUT',
1552 if ( $circulation_alert->is_enabled_for( \%conditions ) ) {
1553 SendCirculationAlert(
1556 item => $item_object->unblessed,
1557 borrower => $borrower,
1558 branch => $branchcode,
1563 "CIRCULATION", "ISSUE",
1564 $borrower->{'borrowernumber'},
1565 $item_object->itemnumber,
1566 ) if C4::Context->preference("IssueLog");
1572 =head2 GetLoanLength
1574 my $loanlength = &GetLoanLength($borrowertype,$itemtype,branchcode)
1576 Get loan length for an itemtype, a borrower type and a branch
1581 my ( $categorycode, $itemtype, $branchcode ) = @_;
1583 # Set search precedences
1586 categorycode => $categorycode,
1587 itemtype => $itemtype,
1588 branchcode => $branchcode,
1591 categorycode => $categorycode,
1593 branchcode => $branchcode,
1596 categorycode => undef,
1597 itemtype => $itemtype,
1598 branchcode => $branchcode,
1601 categorycode => undef,
1603 branchcode => $branchcode,
1606 categorycode => $categorycode,
1607 itemtype => $itemtype,
1608 branchcode => undef,
1611 categorycode => $categorycode,
1613 branchcode => undef,
1616 categorycode => undef,
1617 itemtype => $itemtype,
1618 branchcode => undef,
1621 categorycode => undef,
1623 branchcode => undef,
1627 # Initialize default values
1631 lengthunit => 'days',
1635 foreach my $rule_name (qw( issuelength renewalperiod lengthunit )) {
1636 foreach my $params (@params) {
1637 my $rule = Koha::CirculationRules->search(
1639 rule_name => $rule_name,
1645 $rules->{$rule_name} = $rule->rule_value;
1655 =head2 GetHardDueDate
1657 my ($hardduedate,$hardduedatecompare) = &GetHardDueDate($borrowertype,$itemtype,branchcode)
1659 Get the Hard Due Date and it's comparison for an itemtype, a borrower type and a branch
1663 sub GetHardDueDate {
1664 my ( $borrowertype, $itemtype, $branchcode ) = @_;
1666 my $rules = Koha::CirculationRules->get_effective_rules(
1668 categorycode => $borrowertype,
1669 itemtype => $itemtype,
1670 branchcode => $branchcode,
1671 rules => [ 'hardduedate', 'hardduedatecompare' ],
1675 if ( defined( $rules->{hardduedate} ) ) {
1676 if ( $rules->{hardduedate} ) {
1677 return ( dt_from_string( $rules->{hardduedate}, 'iso' ), $rules->{hardduedatecompare} );
1680 return ( undef, undef );
1685 =head2 GetBranchBorrowerCircRule
1687 my $branch_cat_rule = GetBranchBorrowerCircRule($branchcode, $categorycode);
1689 Retrieves circulation rule attributes that apply to the given
1690 branch and patron category, regardless of item type.
1691 The return value is a hashref containing the following key:
1693 patron_maxissueqty - maximum number of loans that a
1694 patron of the given category can have at the given
1695 branch. If the value is undef, no limit.
1697 patron_maxonsiteissueqty - maximum of on-site checkouts that a
1698 patron of the given category can have at the given
1699 branch. If the value is undef, no limit.
1701 This will check for different branch/category combinations in the following order:
1705 default branch and category
1707 If no rule has been found in the database, it will default to
1710 patron_maxissueqty - undef
1711 patron_maxonsiteissueqty - undef
1713 C<$branchcode> and C<$categorycode> should contain the
1714 literal branch code and patron category code, respectively - no
1719 sub GetBranchBorrowerCircRule {
1720 my ( $branchcode, $categorycode ) = @_;
1722 # Initialize default values
1724 patron_maxissueqty => undef,
1725 patron_maxonsiteissueqty => undef,
1729 foreach my $rule_name (qw( patron_maxissueqty patron_maxonsiteissueqty )) {
1730 my $rule = Koha::CirculationRules->get_effective_rule(
1732 categorycode => $categorycode,
1734 branchcode => $branchcode,
1735 rule_name => $rule_name,
1739 $rules->{$rule_name} = $rule->rule_value if defined $rule;
1745 =head2 GetBranchItemRule
1747 my $branch_item_rule = GetBranchItemRule($branchcode, $itemtype);
1749 Retrieves circulation rule attributes that apply to the given
1750 branch and item type, regardless of patron category.
1752 The return value is a hashref containing the following keys:
1754 holdallowed => Hold policy for this branch and itemtype. Possible values:
1755 0: No holds allowed.
1756 1: Holds allowed only by patrons that have the same homebranch as the item.
1757 2: Holds allowed from any patron.
1759 returnbranch => branch to which to return item. Possible values:
1760 noreturn: do not return, let item remain where checked in (floating collections)
1761 homebranch: return to item's home branch
1762 holdingbranch: return to issuer branch
1764 This searches branchitemrules in the following order:
1766 * Same branchcode and itemtype
1767 * Same branchcode, itemtype '*'
1768 * branchcode '*', same itemtype
1769 * branchcode and itemtype '*'
1771 Neither C<$branchcode> nor C<$itemtype> should be '*'.
1775 sub GetBranchItemRule {
1776 my ( $branchcode, $itemtype ) = @_;
1779 my $holdallowed_rule = Koha::CirculationRules->get_effective_rule(
1781 branchcode => $branchcode,
1782 itemtype => $itemtype,
1783 rule_name => 'holdallowed',
1786 my $hold_fulfillment_policy_rule = Koha::CirculationRules->get_effective_rule(
1788 branchcode => $branchcode,
1789 itemtype => $itemtype,
1790 rule_name => 'hold_fulfillment_policy',
1793 my $returnbranch_rule = Koha::CirculationRules->get_effective_rule(
1795 branchcode => $branchcode,
1796 itemtype => $itemtype,
1797 rule_name => 'returnbranch',
1801 # built-in default circulation rule
1803 $rules->{holdallowed} = defined $holdallowed_rule
1804 ? $holdallowed_rule->rule_value
1806 $rules->{hold_fulfillment_policy} = defined $hold_fulfillment_policy_rule
1807 ? $hold_fulfillment_policy_rule->rule_value
1809 $rules->{returnbranch} = defined $returnbranch_rule
1810 ? $returnbranch_rule->rule_value
1818 ($doreturn, $messages, $iteminformation, $borrower) =
1819 &AddReturn( $barcode, $branch [,$exemptfine] [,$returndate] );
1825 =item C<$barcode> is the bar code of the book being returned.
1827 =item C<$branch> is the code of the branch where the book is being returned.
1829 =item C<$exemptfine> indicates that overdue charges for the item will be
1832 =item C<$return_date> allows the default return date to be overridden
1833 by the given return date. Optional.
1837 C<&AddReturn> returns a list of four items:
1839 C<$doreturn> is true iff the return succeeded.
1841 C<$messages> is a reference-to-hash giving feedback on the operation.
1842 The keys of the hash are:
1848 No item with this barcode exists. The value is C<$barcode>.
1852 The book is not currently on loan. The value is C<$barcode>.
1856 This book has been withdrawn/cancelled. The value should be ignored.
1858 =item C<Wrongbranch>
1860 This book has was returned to the wrong branch. The value is a hashref
1861 so that C<$messages->{Wrongbranch}->{Wrongbranch}> and C<$messages->{Wrongbranch}->{Rightbranch}>
1862 contain the branchcode of the incorrect and correct return library, respectively.
1866 The item was reserved. The value is a reference-to-hash whose keys are
1867 fields from the reserves table of the Koha database, and
1868 C<biblioitemnumber>. It also has the key C<ResFound>, whose value is
1869 either C<Waiting>, C<Reserved>, or 0.
1871 =item C<WasReturned>
1873 Value 1 if return is successful.
1875 =item C<NeedsTransfer>
1877 If AutomaticItemReturn is disabled, return branch is given as value of NeedsTransfer.
1881 C<$iteminformation> is a reference-to-hash, giving information about the
1882 returned item from the issues table.
1884 C<$borrower> is a reference-to-hash, giving information about the
1885 patron who last borrowed the book.
1890 my ( $barcode, $branch, $exemptfine, $return_date ) = @_;
1892 if ($branch and not Koha::Libraries->find($branch)) {
1893 warn "AddReturn error: branch '$branch' not found. Reverting to " . C4::Context->userenv->{'branch'};
1896 $branch = C4::Context->userenv->{'branch'} unless $branch; # we trust userenv to be a safe fallback/default
1897 my $return_date_specified = !!$return_date;
1898 $return_date //= dt_from_string();
1902 my $validTransfert = 0;
1903 my $stat_type = 'return';
1905 # get information on item
1906 my $item = Koha::Items->find({ barcode => $barcode });
1908 return ( 0, { BadBarcode => $barcode } ); # no barcode means no item or borrower. bail out.
1911 my $itemnumber = $item->itemnumber;
1912 my $itemtype = $item->effective_itemtype;
1914 my $issue = $item->checkout;
1916 $patron = $issue->patron
1917 or die "Data inconsistency: barcode $barcode (itemnumber:$itemnumber) claims to be issued to non-existent borrowernumber '" . $issue->borrowernumber . "'\n"
1918 . Dumper($issue->unblessed) . "\n";
1920 $messages->{'NotIssued'} = $barcode;
1921 $item->onloan(undef)->store if defined $item->onloan;
1923 # even though item is not on loan, it may still be transferred; therefore, get current branch info
1925 # No issue, no borrowernumber. ONLY if $doreturn, *might* you have a $borrower later.
1926 # Record this as a local use, instead of a return, if the RecordLocalUseOnReturn is on
1927 if (C4::Context->preference("RecordLocalUseOnReturn")) {
1928 $messages->{'LocalUse'} = 1;
1929 $stat_type = 'localuse';
1933 # full item data, but no borrowernumber or checkout info (no issue)
1934 my $hbr = GetBranchItemRule($item->homebranch, $itemtype)->{'returnbranch'} || "homebranch";
1935 # get the proper branch to which to return the item
1936 my $returnbranch = $hbr ne 'noreturn' ? $item->$hbr : $branch;
1937 # if $hbr was "noreturn" or any other non-item table value, then it should 'float' (i.e. stay at this branch)
1938 my $transfer_trigger = $hbr eq 'homebranch' ? 'ReturnToHome' : $hbr eq 'holdingbranch' ? 'ReturnToHolding' : undef;
1940 my $borrowernumber = $patron ? $patron->borrowernumber : undef; # we don't know if we had a borrower or not
1941 my $patron_unblessed = $patron ? $patron->unblessed : {};
1943 my $update_loc_rules = get_yaml_pref_hash('UpdateItemLocationOnCheckin');
1944 map { $update_loc_rules->{$_} = $update_loc_rules->{$_}[0] } keys %$update_loc_rules; #We can only move to one location so we flatten the arrays
1945 if ($update_loc_rules) {
1946 if (defined $update_loc_rules->{_ALL_}) {
1947 if ($update_loc_rules->{_ALL_} eq '_PERM_') { $update_loc_rules->{_ALL_} = $item->permanent_location; }
1948 if ($update_loc_rules->{_ALL_} eq '_BLANK_') { $update_loc_rules->{_ALL_} = ''; }
1949 if ( $item->location ne $update_loc_rules->{_ALL_}) {
1950 $messages->{'ItemLocationUpdated'} = { from => $item->location, to => $update_loc_rules->{_ALL_} };
1951 $item->location($update_loc_rules->{_ALL_})->store;
1955 foreach my $key ( keys %$update_loc_rules ) {
1956 if ( $update_loc_rules->{$key} eq '_PERM_' ) { $update_loc_rules->{$key} = $item->permanent_location; }
1957 if ( $update_loc_rules->{$key} eq '_BLANK_') { $update_loc_rules->{$key} = '' ;}
1958 if ( ($item->location eq $key && $item->location ne $update_loc_rules->{$key}) || ($key eq '_BLANK_' && $item->location eq '' && $update_loc_rules->{$key} ne '') ) {
1959 $messages->{'ItemLocationUpdated'} = { from => $item->location, to => $update_loc_rules->{$key} };
1960 $item->location($update_loc_rules->{$key})->store;
1967 my $yaml = C4::Context->preference('UpdateNotForLoanStatusOnCheckin');
1969 $yaml = "$yaml\n\n"; # YAML is anal on ending \n. Surplus does not hurt
1971 eval { $rules = YAML::Load($yaml); };
1973 warn "Unable to parse UpdateNotForLoanStatusOnCheckin syspref : $@";
1976 foreach my $key ( keys %$rules ) {
1977 if ( $item->notforloan eq $key ) {
1978 $messages->{'NotForLoanStatusUpdated'} = { from => $item->notforloan, to => $rules->{$key} };
1979 $item->notforloan($rules->{$key})->store({ log_action => 0 });
1986 # check if the return is allowed at this branch
1987 my ($returnallowed, $message) = CanBookBeReturned($item->unblessed, $branch);
1988 unless ($returnallowed){
1989 $messages->{'Wrongbranch'} = {
1990 Wrongbranch => $branch,
1991 Rightbranch => $message
1994 return ( $doreturn, $messages, $issue, $patron_unblessed);
1997 if ( $item->withdrawn ) { # book has been cancelled
1998 $messages->{'withdrawn'} = 1;
1999 $doreturn = 0 if C4::Context->preference("BlockReturnOfWithdrawnItems");
2002 if ( $item->itemlost and C4::Context->preference("BlockReturnOfLostItems") ) {
2006 # case of a return of document (deal with issues and holdingbranch)
2008 die "The item is not issed and cannot be returned" unless $issue; # Just in case...
2009 $patron or warn "AddReturn without current borrower";
2013 MarkIssueReturned( $borrowernumber, $item->itemnumber, $return_date, $patron->privacy );
2018 C4::Context->preference('CalculateFinesOnReturn')
2019 || ( $return_date_specified && C4::Context->preference('CalculateFinesOnBackdate') )
2024 _CalculateAndUpdateFine( { issue => $issue, item => $item->unblessed, borrower => $patron_unblessed, return_date => $return_date } );
2027 carp "The checkin for the following issue failed, Please go to the about page, section 'data corrupted' to know how to fix this problem ($@)" . Dumper( $issue->unblessed );
2029 return ( 0, { WasReturned => 0, DataCorrupted => 1 }, $issue, $patron_unblessed );
2032 # FIXME is the "= 1" right? This could be the borrower hash.
2033 $messages->{'WasReturned'} = 1;
2037 $item->onloan(undef)->store({ log_action => 0 });
2040 # the holdingbranch is updated if the document is returned to another location.
2041 # this is always done regardless of whether the item was on loan or not
2042 my $item_holding_branch = $item->holdingbranch;
2043 if ($item->holdingbranch ne $branch) {
2044 $item->holdingbranch($branch)->store;
2047 my $leave_item_lost = C4::Context->preference("BlockReturnOfLostItems") ? 1 : 0;
2048 ModDateLastSeen( $item->itemnumber, $leave_item_lost );
2050 # check if we have a transfer for this document
2051 my ($datesent,$frombranch,$tobranch) = GetTransfers( $item->itemnumber );
2053 # if we have a transfer to do, we update the line of transfers with the datearrived
2054 my $is_in_rotating_collection = C4::RotatingCollections::isItemInAnyCollection( $item->itemnumber );
2056 if ( $tobranch eq $branch ) {
2057 my $sth = C4::Context->dbh->prepare(
2058 "UPDATE branchtransfers SET datearrived = now() WHERE itemnumber= ? AND datearrived IS NULL"
2060 $sth->execute( $item->itemnumber );
2062 $messages->{'WrongTransfer'} = $tobranch;
2063 $messages->{'WrongTransferItem'} = $item->itemnumber;
2065 $validTransfert = 1;
2068 # fix up the accounts.....
2069 if ( $item->itemlost ) {
2070 $messages->{'WasLost'} = 1;
2071 unless ( C4::Context->preference("BlockReturnOfLostItems") ) {
2073 my $no_refund_after_days = C4::Context->preference('NoRefundOnLostReturnedItemsAge');
2074 if ($no_refund_after_days) {
2075 my $today = dt_from_string();
2076 my $lost_age_in_days =
2077 dt_from_string( $item->itemlost_on )
2078 ->delta_days($today)
2081 $refund = 0 unless ( $lost_age_in_days < $no_refund_after_days );
2086 Koha::RefundLostItemFeeRules->should_refund(
2088 current_branch => C4::Context->userenv->{branch},
2089 item_home_branch => $item->homebranch,
2090 item_holding_branch => $item_holding_branch
2095 _FixAccountForLostAndFound( $item->itemnumber,
2096 $borrowernumber, $barcode );
2097 $messages->{'LostItemFeeRefunded'} = 1;
2102 # fix up the overdues in accounts...
2103 if ($borrowernumber) {
2104 my $fix = _FixOverduesOnReturn( $borrowernumber, $item->itemnumber, $exemptfine, 'RETURNED' );
2105 defined($fix) or warn "_FixOverduesOnReturn($borrowernumber, ".$item->itemnumber."...) failed!"; # zero is OK, check defined
2107 if ( $issue and $issue->is_overdue($return_date) ) {
2109 my ($debardate,$reminder) = _debar_user_on_return( $patron_unblessed, $item->unblessed, dt_from_string($issue->date_due), $return_date );
2111 $messages->{'PrevDebarred'} = $debardate;
2113 $messages->{'Debarred'} = $debardate if $debardate;
2115 # there's no overdue on the item but borrower had been previously debarred
2116 } elsif ( $issue->date_due and $patron->debarred ) {
2117 if ( $patron->debarred eq "9999-12-31") {
2118 $messages->{'ForeverDebarred'} = $patron->debarred;
2120 my $borrower_debar_dt = dt_from_string( $patron->debarred );
2121 $borrower_debar_dt->truncate(to => 'day');
2122 my $today_dt = $return_date->clone()->truncate(to => 'day');
2123 if ( DateTime->compare( $borrower_debar_dt, $today_dt ) != -1 ) {
2124 $messages->{'PrevDebarred'} = $patron->debarred;
2130 # find reserves.....
2131 # launch the Checkreserves routine to find any holds
2132 my ($resfound, $resrec);
2133 my $lookahead= C4::Context->preference('ConfirmFutureHolds'); #number of days to look for future holds
2134 ($resfound, $resrec, undef) = C4::Reserves::CheckReserves( $item->itemnumber, undef, $lookahead ) unless ( $item->withdrawn );
2135 # if a hold is found and is waiting at another branch, change the priority back to 1 and trigger the hold (this will trigger a transfer and update the hold status properly)
2136 if ( $resfound eq "Waiting" and $branch ne $resrec->{branchcode} ) {
2137 my $hold = C4::Reserves::RevertWaitingStatus( { itemnumber => $item->itemnumber } );
2138 $resfound = 'Reserved';
2139 $resrec = $hold->unblessed;
2142 $resrec->{'ResFound'} = $resfound;
2143 $messages->{'ResFound'} = $resrec;
2146 _after_circ_actions(
2148 action => 'checkin',
2150 library_id => C4::Context->userenv->{'branch'},
2151 item_id => $item->itemnumber,
2152 item_type => $item->effective_itemtype,
2153 shelving_location => $item->location // q{},
2154 patron_id => $borrowernumber,
2155 collection_code => $item->ccode // q{},
2156 date_returned => $return_date,
2157 date_due => $issue ? $issue->date_due : q{}
2160 ) if C4::Context->config("enable_plugins");
2162 # Record the fact that this book was returned.
2166 itemnumber => $itemnumber,
2167 itemtype => $itemtype,
2168 location => $item->location,
2169 borrowernumber => $borrowernumber,
2170 ccode => $item->ccode,
2173 # Send a check-in slip. # NOTE: borrower may be undef. Do not try to send messages then.
2175 my $circulation_alert = 'C4::ItemCirculationAlertPreference';
2177 branchcode => $branch,
2178 categorycode => $patron->categorycode,
2179 item_type => $itemtype,
2180 notification => 'CHECKIN',
2182 if ($doreturn && $circulation_alert->is_enabled_for(\%conditions)) {
2183 SendCirculationAlert({
2185 item => $item->unblessed,
2186 borrower => $patron->unblessed,
2191 logaction("CIRCULATION", "RETURN", $borrowernumber, $item->itemnumber)
2192 if C4::Context->preference("ReturnLog");
2195 # Check if this item belongs to a biblio record that is attached to an
2196 # ILL request, if it is we need to update the ILL request's status
2197 if (C4::Context->preference('CirculateILL')) {
2198 my $request = Koha::Illrequests->find(
2199 { biblio_id => $item->biblio->biblionumber }
2201 $request->status('RET') if $request;
2204 # Transfer to returnbranch if Automatic transfer set or append message NeedsTransfer
2205 if (!$is_in_rotating_collection && ($doreturn or $messages->{'NotIssued'}) and !$resfound and ($branch ne $returnbranch) and not $messages->{'WrongTransfer'}){
2206 my $BranchTransferLimitsType = C4::Context->preference("BranchTransferLimitsType") eq 'itemtype' ? 'effective_itemtype' : 'ccode';
2207 if (C4::Context->preference("AutomaticItemReturn" ) or
2208 (C4::Context->preference("UseBranchTransferLimits") and
2209 ! IsBranchTransferAllowed($branch, $returnbranch, $item->$BranchTransferLimitsType )
2211 $debug and warn sprintf "about to call ModItemTransfer(%s, %s, %s, %s)", $item->itemnumber,$branch, $returnbranch, $transfer_trigger;
2212 $debug and warn "item: " . Dumper($item->unblessed);
2213 ModItemTransfer($item->itemnumber, $branch, $returnbranch, $transfer_trigger);
2214 $messages->{'WasTransfered'} = 1;
2216 $messages->{'NeedsTransfer'} = $returnbranch;
2217 $messages->{'TransferTrigger'} = $transfer_trigger;
2221 if ( C4::Context->preference('ClaimReturnedLostValue') ) {
2222 my $claims = Koha::Checkouts::ReturnClaims->search(
2224 itemnumber => $item->id,
2225 resolution => undef,
2229 if ( $claims->count ) {
2230 $messages->{ReturnClaims} = $claims;
2234 return ( $doreturn, $messages, $issue, ( $patron ? $patron->unblessed : {} ));
2237 =head2 MarkIssueReturned
2239 MarkIssueReturned($borrowernumber, $itemnumber, $returndate, $privacy);
2241 Unconditionally marks an issue as being returned by
2242 moving the C<issues> row to C<old_issues> and
2243 setting C<returndate> to the current date.
2245 if C<$returndate> is specified (in iso format), it is used as the date
2248 C<$privacy> contains the privacy parameter. If the patron has set privacy to 2,
2249 the old_issue is immediately anonymised
2251 Ideally, this function would be internal to C<C4::Circulation>,
2252 not exported, but it is currently used in misc/cronjobs/longoverdue.pl
2253 and offline_circ/process_koc.pl.
2257 sub MarkIssueReturned {
2258 my ( $borrowernumber, $itemnumber, $returndate, $privacy ) = @_;
2260 # Retrieve the issue
2261 my $issue = Koha::Checkouts->find( { itemnumber => $itemnumber } ) or return;
2263 return unless $issue->borrowernumber == $borrowernumber; # If the item is checked out to another patron we do not return it
2265 my $issue_id = $issue->issue_id;
2267 my $anonymouspatron;
2268 if ( $privacy && $privacy == 2 ) {
2269 # The default of 0 will not work due to foreign key constraints
2270 # The anonymisation will fail if AnonymousPatron is not a valid entry
2271 # We need to check if the anonymous patron exist, Koha will fail loudly if it does not
2272 # Note that a warning should appear on the about page (System information tab).
2273 $anonymouspatron = C4::Context->preference('AnonymousPatron');
2274 die "Fatal error: the patron ($borrowernumber) has requested their circulation history be anonymized on check-in, but the AnonymousPatron system preference is empty or not set correctly."
2275 unless Koha::Patrons->find( $anonymouspatron );
2278 my $schema = Koha::Database->schema;
2280 # FIXME Improve the return value and handle it from callers
2281 $schema->txn_do(sub {
2283 my $patron = Koha::Patrons->find( $borrowernumber );
2285 # Update the returndate value
2286 if ( $returndate ) {
2287 $issue->returndate( $returndate )->store->discard_changes; # update and refetch
2290 $issue->returndate( \'NOW()' )->store->discard_changes; # update and refetch
2293 # Create the old_issues entry
2294 my $old_checkout = Koha::Old::Checkout->new($issue->unblessed)->store;
2296 # anonymise patron checkout immediately if $privacy set to 2 and AnonymousPatron is set to a valid borrowernumber
2297 if ( $privacy && $privacy == 2) {
2298 $old_checkout->borrowernumber($anonymouspatron)->store;
2301 # And finally delete the issue
2304 $issue->item->onloan(undef)->store({ log_action => 0 });
2306 if ( C4::Context->preference('StoreLastBorrower') ) {
2307 my $item = Koha::Items->find( $itemnumber );
2308 $item->last_returned_by( $patron );
2311 # Remove any OVERDUES related debarment if the borrower has no overdues
2312 if ( C4::Context->preference('AutoRemoveOverduesRestrictions')
2313 && $patron->debarred
2314 && !$patron->has_overdues
2315 && @{ GetDebarments({ borrowernumber => $borrowernumber, type => 'OVERDUES' }) }
2317 DelUniqueDebarment({ borrowernumber => $borrowernumber, type => 'OVERDUES' });
2325 =head2 _debar_user_on_return
2327 _debar_user_on_return($borrower, $item, $datedue, $returndate);
2329 C<$borrower> borrower hashref
2331 C<$item> item hashref
2333 C<$datedue> date due DateTime object
2335 C<$returndate> DateTime object representing the return time
2337 Internal function, called only by AddReturn that calculates and updates
2338 the user fine days, and debars them if necessary.
2340 Should only be called for overdue returns
2342 Calculation of the debarment date has been moved to a separate subroutine _calculate_new_debar_dt
2347 sub _calculate_new_debar_dt {
2348 my ( $borrower, $item, $dt_due, $return_date ) = @_;
2350 my $branchcode = _GetCircControlBranch( $item, $borrower );
2351 my $circcontrol = C4::Context->preference('CircControl');
2352 my $issuing_rule = Koha::CirculationRules->get_effective_rules(
2353 { categorycode => $borrower->{categorycode},
2354 itemtype => $item->{itype},
2355 branchcode => $branchcode,
2360 'maxsuspensiondays',
2361 'suspension_chargeperiod',
2365 my $finedays = $issuing_rule ? $issuing_rule->{finedays} : undef;
2366 my $unit = $issuing_rule ? $issuing_rule->{lengthunit} : undef;
2367 my $chargeable_units = C4::Overdues::get_chargeable_units($unit, $dt_due, $return_date, $branchcode);
2369 return unless $finedays;
2371 # finedays is in days, so hourly loans must multiply by 24
2372 # thus 1 hour late equals 1 day suspension * finedays rate
2373 $finedays = $finedays * 24 if ( $unit eq 'hours' );
2375 # grace period is measured in the same units as the loan
2377 DateTime::Duration->new( $unit => $issuing_rule->{firstremind} );
2379 my $deltadays = DateTime::Duration->new(
2380 days => $chargeable_units
2383 if ( $deltadays->subtract($grace)->is_positive() ) {
2384 my $suspension_days = $deltadays * $finedays;
2386 if ( defined $issuing_rule->{suspension_chargeperiod} && $issuing_rule->{suspension_chargeperiod} > 1 ) {
2387 # No need to / 1 and do not consider / 0
2388 $suspension_days = DateTime::Duration->new(
2389 days => floor( $suspension_days->in_units('days') / $issuing_rule->{suspension_chargeperiod} )
2393 # If the max suspension days is < than the suspension days
2394 # the suspension days is limited to this maximum period.
2395 my $max_sd = $issuing_rule->{maxsuspensiondays};
2396 if ( defined $max_sd && $max_sd ne '' ) {
2397 $max_sd = DateTime::Duration->new( days => $max_sd );
2398 $suspension_days = $max_sd
2399 if DateTime::Duration->compare( $max_sd, $suspension_days ) < 0;
2402 my ( $has_been_extended );
2403 if ( C4::Context->preference('CumulativeRestrictionPeriods') and $borrower->{debarred} ) {
2404 my $debarment = @{ GetDebarments( { borrowernumber => $borrower->{borrowernumber}, type => 'SUSPENSION' } ) }[0];
2406 $return_date = dt_from_string( $debarment->{expiration}, 'sql' );
2407 $has_been_extended = 1;
2412 # Use the calendar or not to calculate the debarment date
2413 if ( C4::Context->preference('SuspensionsCalendar') eq 'noSuspensionsWhenClosed' ) {
2414 my $calendar = Koha::Calendar->new(
2415 branchcode => $branchcode,
2416 days_mode => 'Calendar'
2418 $new_debar_dt = $calendar->addDate( $return_date, $suspension_days );
2421 $new_debar_dt = $return_date->clone()->add_duration($suspension_days);
2423 return $new_debar_dt;
2428 sub _debar_user_on_return {
2429 my ( $borrower, $item, $dt_due, $return_date ) = @_;
2431 $return_date //= dt_from_string();
2433 my $new_debar_dt = _calculate_new_debar_dt ($borrower, $item, $dt_due, $return_date);
2435 return unless $new_debar_dt;
2437 Koha::Patron::Debarments::AddUniqueDebarment({
2438 borrowernumber => $borrower->{borrowernumber},
2439 expiration => $new_debar_dt->ymd(),
2440 type => 'SUSPENSION',
2442 # if borrower was already debarred but does not get an extra debarment
2443 my $patron = Koha::Patrons->find( $borrower->{borrowernumber} );
2444 my ($new_debarment_str, $is_a_reminder);
2445 if ( $borrower->{debarred} && $borrower->{debarred} eq $patron->is_debarred ) {
2447 $new_debarment_str = $borrower->{debarred};
2449 $new_debarment_str = $new_debar_dt->ymd();
2451 # FIXME Should return a DateTime object
2452 return $new_debarment_str, $is_a_reminder;
2455 =head2 _FixOverduesOnReturn
2457 &_FixOverduesOnReturn($borrowernumber, $itemnumber, $exemptfine, $status);
2459 C<$borrowernumber> borrowernumber
2461 C<$itemnumber> itemnumber
2463 C<$exemptfine> BOOL -- remove overdue charge associated with this issue.
2465 C<$status> ENUM -- reason for fix [ RETURNED, RENEWED, LOST, FORGIVEN ]
2471 sub _FixOverduesOnReturn {
2472 my ( $borrowernumber, $item, $exemptfine, $status ) = @_;
2473 unless( $borrowernumber ) {
2474 warn "_FixOverduesOnReturn() not supplied valid borrowernumber";
2478 warn "_FixOverduesOnReturn() not supplied valid itemnumber";
2482 warn "_FixOverduesOnReturn() not supplied valid status";
2486 my $schema = Koha::Database->schema;
2488 my $result = $schema->txn_do(
2490 # check for overdue fine
2491 my $accountlines = Koha::Account::Lines->search(
2493 borrowernumber => $borrowernumber,
2494 itemnumber => $item,
2495 debit_type_code => 'OVERDUE',
2496 status => 'UNRETURNED'
2499 return 0 unless $accountlines->count; # no warning, there's just nothing to fix
2501 my $accountline = $accountlines->next;
2502 my $payments = $accountline->credits;
2504 my $amountoutstanding = $accountline->amountoutstanding;
2505 if ( $accountline->amount == 0 && $payments->count == 0 ) {
2506 $accountline->delete;
2507 } elsif ($exemptfine && ($amountoutstanding != 0)) {
2508 my $account = Koha::Account->new({patron_id => $borrowernumber});
2509 my $credit = $account->add_credit(
2511 amount => $amountoutstanding,
2512 user_id => C4::Context->userenv ? C4::Context->userenv->{'number'} : undef,
2513 library_id => C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef,
2514 interface => C4::Context->interface,
2520 $credit->apply({ debits => [ $accountline ], offset_type => 'Forgiven' });
2522 if (C4::Context->preference("FinesLog")) {
2523 &logaction("FINES", 'MODIFY',$borrowernumber,"Overdue forgiven: item $item");
2526 $accountline->status('FORGIVEN');
2527 $accountline->store();
2529 $accountline->status($status);
2530 $accountline->store();
2539 =head2 _FixAccountForLostAndFound
2541 &_FixAccountForLostAndFound($itemnumber, [$borrowernumber, $barcode]);
2543 Finds the most recent lost item charge for this item and refunds the borrower
2544 appropriatly, taking into account any payments or writeoffs already applied
2547 Internal function, not exported, called only by AddReturn.
2551 sub _FixAccountForLostAndFound {
2552 my $itemnumber = shift or return;
2553 my $borrowernumber = @_ ? shift : undef;
2554 my $item_id = @_ ? shift : $itemnumber; # Send the barcode if you want that logged in the description
2558 # check for charge made for lost book
2559 my $accountlines = Koha::Account::Lines->search(
2561 itemnumber => $itemnumber,
2562 debit_type_code => 'LOST',
2563 status => [ undef, { '<>' => 'FOUND' } ]
2566 order_by => { -desc => [ 'date', 'accountlines_id' ] }
2570 return unless $accountlines->count > 0;
2571 my $accountline = $accountlines->next;
2572 my $total_to_refund = 0;
2574 return unless $accountline->borrowernumber;
2575 my $patron = Koha::Patrons->find( $accountline->borrowernumber );
2576 return unless $patron; # Patron has been deleted, nobody to credit the return to
2578 my $account = $patron->account;
2581 if ( $accountline->amount > $accountline->amountoutstanding ) {
2582 # some amount has been cancelled. collect the offsets that are not writeoffs
2583 # this works because the only way to subtract from this kind of a debt is
2584 # using the UI buttons 'Pay' and 'Write off'
2585 my $credits_offsets = Koha::Account::Offsets->search({
2586 debit_id => $accountline->id,
2587 credit_id => { '!=' => undef }, # it is not the debit itself
2588 type => { '!=' => 'Writeoff' },
2589 amount => { '<' => 0 } # credits are negative on the DB
2592 $total_to_refund = ( $credits_offsets->count > 0 )
2593 ? $credits_offsets->total * -1 # credits are negative on the DB
2597 my $credit_total = $accountline->amountoutstanding + $total_to_refund;
2599 if ( $credit_total > 0 ) {
2600 my $branchcode = C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
2601 $credit = $account->add_credit(
2603 amount => $credit_total,
2604 description => 'Item found ' . $item_id,
2605 type => 'LOST_FOUND',
2606 interface => C4::Context->interface,
2607 library_id => $branchcode,
2608 item_id => $itemnumber
2612 $credit->apply( { debits => [ $accountline ] } );
2615 # Update the account status
2616 $accountline->discard_changes->status('FOUND');
2617 $accountline->store;
2619 $accountline->item->paidfor('')->store({ log_action => 0 });
2621 if ( defined $account and C4::Context->preference('AccountAutoReconcile') ) {
2622 $account->reconcile_balance;
2625 return ($credit) ? $credit->id : undef;
2628 =head2 _GetCircControlBranch
2630 my $circ_control_branch = _GetCircControlBranch($iteminfos, $borrower);
2634 Return the library code to be used to determine which circulation
2635 policy applies to a transaction. Looks up the CircControl and
2636 HomeOrHoldingBranch system preferences.
2638 C<$iteminfos> is a hashref to iteminfo. Only {homebranch or holdingbranch} is used.
2640 C<$borrower> is a hashref to borrower. Only {branchcode} is used.
2644 sub _GetCircControlBranch {
2645 my ($item, $borrower) = @_;
2646 my $circcontrol = C4::Context->preference('CircControl');
2649 if ($circcontrol eq 'PickupLibrary' and (C4::Context->userenv and C4::Context->userenv->{'branch'}) ) {
2650 $branch= C4::Context->userenv->{'branch'};
2651 } elsif ($circcontrol eq 'PatronLibrary') {
2652 $branch=$borrower->{branchcode};
2654 my $branchfield = C4::Context->preference('HomeOrHoldingBranch') || 'homebranch';
2655 $branch = $item->{$branchfield};
2656 # default to item home branch if holdingbranch is used
2657 # and is not defined
2658 if (!defined($branch) && $branchfield eq 'holdingbranch') {
2659 $branch = $item->{homebranch};
2667 $issue = GetOpenIssue( $itemnumber );
2669 Returns the row from the issues table if the item is currently issued, undef if the item is not currently issued
2671 C<$itemnumber> is the item's itemnumber
2678 my ( $itemnumber ) = @_;
2679 return unless $itemnumber;
2680 my $dbh = C4::Context->dbh;
2681 my $sth = $dbh->prepare( "SELECT * FROM issues WHERE itemnumber = ? AND returndate IS NULL" );
2682 $sth->execute( $itemnumber );
2683 return $sth->fetchrow_hashref();
2687 =head2 GetBiblioIssues
2689 $issues = GetBiblioIssues($biblionumber);
2691 this function get all issues from a biblionumber.
2694 C<$issues> is a reference to array which each value is ref-to-hash. This ref-to-hash contains all column from
2695 tables issues and the firstname,surname & cardnumber from borrowers.
2699 sub GetBiblioIssues {
2700 my $biblionumber = shift;
2701 return unless $biblionumber;
2702 my $dbh = C4::Context->dbh;
2704 SELECT issues.*,items.barcode,biblio.biblionumber,biblio.title, biblio.author,borrowers.cardnumber,borrowers.surname,borrowers.firstname
2706 LEFT JOIN borrowers ON borrowers.borrowernumber = issues.borrowernumber
2707 LEFT JOIN items ON issues.itemnumber = items.itemnumber
2708 LEFT JOIN biblioitems ON items.itemnumber = biblioitems.biblioitemnumber
2709 LEFT JOIN biblio ON biblio.biblionumber = items.biblionumber
2710 WHERE biblio.biblionumber = ?
2712 SELECT old_issues.*,items.barcode,biblio.biblionumber,biblio.title, biblio.author,borrowers.cardnumber,borrowers.surname,borrowers.firstname
2714 LEFT JOIN borrowers ON borrowers.borrowernumber = old_issues.borrowernumber
2715 LEFT JOIN items ON old_issues.itemnumber = items.itemnumber
2716 LEFT JOIN biblioitems ON items.itemnumber = biblioitems.biblioitemnumber
2717 LEFT JOIN biblio ON biblio.biblionumber = items.biblionumber
2718 WHERE biblio.biblionumber = ?
2721 my $sth = $dbh->prepare($query);
2722 $sth->execute($biblionumber, $biblionumber);
2725 while ( my $data = $sth->fetchrow_hashref ) {
2726 push @issues, $data;
2731 =head2 GetUpcomingDueIssues
2733 my $upcoming_dues = GetUpcomingDueIssues( { days_in_advance => 4 } );
2737 sub GetUpcomingDueIssues {
2740 $params->{'days_in_advance'} = 7 unless exists $params->{'days_in_advance'};
2741 my $dbh = C4::Context->dbh;
2743 my $statement = <<END_SQL;
2746 SELECT issues.*, items.itype as itemtype, items.homebranch, TO_DAYS( date_due )-TO_DAYS( NOW() ) as days_until_due, branches.branchemail
2748 LEFT JOIN items USING (itemnumber)
2749 LEFT OUTER JOIN branches USING (branchcode)
2750 WHERE returndate is NULL
2752 WHERE days_until_due >= 0 AND days_until_due <= ?
2755 my @bind_parameters = ( $params->{'days_in_advance'} );
2757 my $sth = $dbh->prepare( $statement );
2758 $sth->execute( @bind_parameters );
2759 my $upcoming_dues = $sth->fetchall_arrayref({});
2761 return $upcoming_dues;
2764 =head2 CanBookBeRenewed
2766 ($ok,$error) = &CanBookBeRenewed($borrowernumber, $itemnumber[, $override_limit]);
2768 Find out whether a borrowed item may be renewed.
2770 C<$borrowernumber> is the borrower number of the patron who currently
2771 has the item on loan.
2773 C<$itemnumber> is the number of the item to renew.
2775 C<$override_limit>, if supplied with a true value, causes
2776 the limit on the number of times that the loan can be renewed
2777 (as controlled by the item type) to be ignored. Overriding also allows
2778 to renew sooner than "No renewal before" and to manually renew loans
2779 that are automatically renewed.
2781 C<$CanBookBeRenewed> returns a true value if the item may be renewed. The
2782 item must currently be on loan to the specified borrower; renewals
2783 must be allowed for the item's type; and the borrower must not have
2784 already renewed the loan. $error will contain the reason the renewal can not proceed
2788 sub CanBookBeRenewed {
2789 my ( $borrowernumber, $itemnumber, $override_limit ) = @_;
2791 my $dbh = C4::Context->dbh;
2795 my $item = Koha::Items->find($itemnumber) or return ( 0, 'no_item' );
2796 my $issue = $item->checkout or return ( 0, 'no_checkout' );
2797 return ( 0, 'onsite_checkout' ) if $issue->onsite_checkout;
2798 return ( 0, 'item_denied_renewal') if _item_denied_renewal({ item => $item });
2800 my $patron = $issue->patron or return;
2802 # override_limit will override anything else except on_reserve
2803 unless ( $override_limit ){
2804 my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
2805 my $issuing_rule = Koha::CirculationRules->get_effective_rules(
2807 categorycode => $patron->categorycode,
2808 itemtype => $item->effective_itemtype,
2809 branchcode => $branchcode,
2812 'no_auto_renewal_after',
2813 'no_auto_renewal_after_hard_limit',
2820 return ( 0, "too_many" )
2821 if not $issuing_rule->{renewalsallowed} or $issuing_rule->{renewalsallowed} <= $issue->renewals;
2823 my $overduesblockrenewing = C4::Context->preference('OverduesBlockRenewing');
2824 my $restrictionblockrenewing = C4::Context->preference('RestrictionBlockRenewing');
2825 $patron = Koha::Patrons->find($borrowernumber); # FIXME Is this really useful?
2826 my $restricted = $patron->is_debarred;
2827 my $hasoverdues = $patron->has_overdues;
2829 if ( $restricted and $restrictionblockrenewing ) {
2830 return ( 0, 'restriction');
2831 } elsif ( ($hasoverdues and $overduesblockrenewing eq 'block') || ($issue->is_overdue and $overduesblockrenewing eq 'blockitem') ) {
2832 return ( 0, 'overdue');
2835 if ( $issue->auto_renew && $patron->autorenew_checkouts ) {
2837 if ( $patron->category->effective_BlockExpiredPatronOpacActions and $patron->is_expired ) {
2838 return ( 0, 'auto_account_expired' );
2841 if ( defined $issuing_rule->{no_auto_renewal_after}
2842 and $issuing_rule->{no_auto_renewal_after} ne "" ) {
2843 # Get issue_date and add no_auto_renewal_after
2844 # If this is greater than today, it's too late for renewal.
2845 my $maximum_renewal_date = dt_from_string($issue->issuedate, 'sql');
2846 $maximum_renewal_date->add(
2847 $issuing_rule->{lengthunit} => $issuing_rule->{no_auto_renewal_after}
2849 my $now = dt_from_string;
2850 if ( $now >= $maximum_renewal_date ) {
2851 return ( 0, "auto_too_late" );
2854 if ( defined $issuing_rule->{no_auto_renewal_after_hard_limit}
2855 and $issuing_rule->{no_auto_renewal_after_hard_limit} ne "" ) {
2856 # If no_auto_renewal_after_hard_limit is >= today, it's also too late for renewal
2857 if ( dt_from_string >= dt_from_string( $issuing_rule->{no_auto_renewal_after_hard_limit} ) ) {
2858 return ( 0, "auto_too_late" );
2862 if ( C4::Context->preference('OPACFineNoRenewalsBlockAutoRenew') ) {
2863 my $fine_no_renewals = C4::Context->preference("OPACFineNoRenewals");
2864 my $amountoutstanding =
2865 C4::Context->preference("OPACFineNoRenewalsIncludeCredit")
2866 ? $patron->account->balance
2867 : $patron->account->outstanding_debits->total_outstanding;
2868 if ( $amountoutstanding and $amountoutstanding > $fine_no_renewals ) {
2869 return ( 0, "auto_too_much_oweing" );
2874 if ( defined $issuing_rule->{norenewalbefore}
2875 and $issuing_rule->{norenewalbefore} ne "" )
2878 # Calculate soonest renewal by subtracting 'No renewal before' from due date
2879 my $soonestrenewal = dt_from_string( $issue->date_due, 'sql' )->subtract(
2880 $issuing_rule->{lengthunit} => $issuing_rule->{norenewalbefore} );
2882 # Depending on syspref reset the exact time, only check the date
2883 if ( C4::Context->preference('NoRenewalBeforePrecision') eq 'date'
2884 and $issuing_rule->{lengthunit} eq 'days' )
2886 $soonestrenewal->truncate( to => 'day' );
2889 if ( $soonestrenewal > dt_from_string() )
2891 return ( 0, "auto_too_soon" ) if $issue->auto_renew && $patron->autorenew_checkouts;
2892 return ( 0, "too_soon" );
2894 elsif ( $issue->auto_renew && $patron->autorenew_checkouts ) {
2899 # Fallback for automatic renewals:
2900 # If norenewalbefore is undef, don't renew before due date.
2901 if ( $issue->auto_renew && !$auto_renew && $patron->autorenew_checkouts ) {
2902 my $now = dt_from_string;
2903 if ( $now >= dt_from_string( $issue->date_due, 'sql' ) ){
2906 return ( 0, "auto_too_soon" );
2911 my ( $resfound, $resrec, undef ) = C4::Reserves::CheckReserves($itemnumber);
2913 # This item can fill one or more unfilled reserve, can those unfilled reserves
2914 # all be filled by other available items?
2916 && C4::Context->preference('AllowRenewalIfOtherItemsAvailable') )
2918 my $schema = Koha::Database->new()->schema();
2920 my $item_holds = $schema->resultset('Reserve')->search( { itemnumber => $itemnumber, found => undef } )->count();
2922 # There is an item level hold on this item, no other item can fill the hold
2927 # Get all other items that could possibly fill reserves
2928 my @itemnumbers = $schema->resultset('Item')->search(
2930 biblionumber => $resrec->{biblionumber},
2933 -not => { itemnumber => $itemnumber }
2935 { columns => 'itemnumber' }
2936 )->get_column('itemnumber')->all();
2938 # Get all other reserves that could have been filled by this item
2939 my @borrowernumbers;
2941 my ( $reserve_found, $reserve, undef ) =
2942 C4::Reserves::CheckReserves( $itemnumber, undef, undef, \@borrowernumbers );
2944 if ($reserve_found) {
2945 push( @borrowernumbers, $reserve->{borrowernumber} );
2952 # If the count of the union of the lists of reservable items for each borrower
2953 # is equal or greater than the number of borrowers, we know that all reserves
2954 # can be filled with available items. We can get the union of the sets simply
2955 # by pushing all the elements onto an array and removing the duplicates.
2958 ITEM: foreach my $itemnumber (@itemnumbers) {
2959 my $item = Koha::Items->find( $itemnumber );
2960 next if IsItemOnHoldAndFound( $itemnumber );
2961 for my $borrowernumber (@borrowernumbers) {
2962 my $patron = $patrons{$borrowernumber} //= Koha::Patrons->find( $borrowernumber );
2963 next unless IsAvailableForItemLevelRequest($item, $patron);
2964 next unless CanItemBeReserved($borrowernumber,$itemnumber);
2966 push @reservable, $itemnumber;
2967 if (@reservable >= @borrowernumbers) {
2976 return ( 0, "on_reserve" ) if $resfound; # '' when no hold was found
2977 return ( 0, "auto_renew" ) if $auto_renew && !$override_limit; # 0 if auto-renewal should not succeed
2979 return ( 1, undef );
2984 &AddRenewal($borrowernumber, $itemnumber, $branch, [$datedue], [$lastreneweddate]);
2988 C<$borrowernumber> is the borrower number of the patron who currently
2991 C<$itemnumber> is the number of the item to renew.
2993 C<$branch> is the library where the renewal took place (if any).
2994 The library that controls the circ policies for the renewal is retrieved from the issues record.
2996 C<$datedue> can be a DateTime object used to set the due date.
2998 C<$lastreneweddate> is an optional ISO-formatted date used to set issues.lastreneweddate. If
2999 this parameter is not supplied, lastreneweddate is set to the current date.
3001 C<$skipfinecalc> is an optional boolean. There may be circumstances where, even if the
3002 CalculateFinesOnReturn syspref is enabled, we don't want to calculate fines upon renew,
3003 for example, when we're renewing as a result of a fine being paid (see RenewAccruingItemWhenPaid
3006 If C<$datedue> is the empty string, C<&AddRenewal> will calculate the due date automatically
3007 from the book's item type.
3012 my $borrowernumber = shift;
3013 my $itemnumber = shift or return;
3015 my $datedue = shift;
3016 my $lastreneweddate = shift || dt_from_string();
3017 my $skipfinecalc = shift;
3019 my $item_object = Koha::Items->find($itemnumber) or return;
3020 my $biblio = $item_object->biblio;
3021 my $issue = $item_object->checkout;
3022 my $item_unblessed = $item_object->unblessed;
3024 my $dbh = C4::Context->dbh;
3026 return unless $issue;
3028 $borrowernumber ||= $issue->borrowernumber;
3030 if ( defined $datedue && ref $datedue ne 'DateTime' ) {
3031 carp 'Invalid date passed to AddRenewal.';
3035 my $patron = Koha::Patrons->find( $borrowernumber ) or return; # FIXME Should do more than just return
3036 my $patron_unblessed = $patron->unblessed;
3038 my $circ_library = Koha::Libraries->find( _GetCircControlBranch($item_unblessed, $patron_unblessed) );
3040 my $schema = Koha::Database->schema;
3041 $schema->txn_do(sub{
3043 if ( !$skipfinecalc && C4::Context->preference('CalculateFinesOnReturn') ) {
3044 _CalculateAndUpdateFine( { issue => $issue, item => $item_unblessed, borrower => $patron_unblessed } );
3046 _FixOverduesOnReturn( $borrowernumber, $itemnumber, undef, 'RENEWED' );
3048 # If the due date wasn't specified, calculate it by adding the
3049 # book's loan length to today's date or the current due date
3050 # based on the value of the RenewalPeriodBase syspref.
3051 my $itemtype = $item_object->effective_itemtype;
3054 $datedue = (C4::Context->preference('RenewalPeriodBase') eq 'date_due') ?
3055 dt_from_string( $issue->date_due, 'sql' ) :
3057 $datedue = CalcDateDue($datedue, $itemtype, $circ_library->branchcode, $patron_unblessed, 'is a renewal');
3060 my $fees = Koha::Charges::Fees->new(
3063 library => $circ_library,
3064 item => $item_object,
3065 from_date => dt_from_string( $issue->date_due, 'sql' ),
3066 to_date => dt_from_string($datedue),
3070 # Update the issues record to have the new due date, and a new count
3071 # of how many times it has been renewed.
3072 my $renews = ( $issue->renewals || 0 ) + 1;
3073 my $sth = $dbh->prepare("UPDATE issues SET date_due = ?, renewals = ?, lastreneweddate = ?
3074 WHERE borrowernumber=?
3078 $sth->execute( $datedue->strftime('%Y-%m-%d %H:%M'), $renews, $lastreneweddate, $borrowernumber, $itemnumber );
3080 # Update the renewal count on the item, and tell zebra to reindex
3081 $renews = ( $item_object->renewals || 0 ) + 1;
3082 $item_object->renewals($renews);
3083 $item_object->onloan($datedue);
3084 $item_object->store({ log_action => 0 });
3086 # Charge a new rental fee, if applicable
3087 my ( $charge, $type ) = GetIssuingCharges( $itemnumber, $borrowernumber );
3088 if ( $charge > 0 ) {
3089 AddIssuingCharge($issue, $charge, 'RENT_RENEW');
3092 # Charge a new accumulate rental fee, if applicable
3093 my $itemtype_object = Koha::ItemTypes->find( $itemtype );
3094 if ( $itemtype_object ) {
3095 my $accumulate_charge = $fees->accumulate_rentalcharge();
3096 if ( $accumulate_charge > 0 ) {
3097 AddIssuingCharge( $issue, $accumulate_charge, 'RENT_DAILY_RENEW' )
3099 $charge += $accumulate_charge;
3102 # Send a renewal slip according to checkout alert preferencei
3103 if ( C4::Context->preference('RenewalSendNotice') eq '1' ) {
3104 my $circulation_alert = 'C4::ItemCirculationAlertPreference';
3106 branchcode => $branch,
3107 categorycode => $patron->categorycode,
3108 item_type => $itemtype,
3109 notification => 'CHECKOUT',
3111 if ( $circulation_alert->is_enabled_for( \%conditions ) ) {
3112 SendCirculationAlert(
3115 item => $item_unblessed,
3116 borrower => $patron->unblessed,
3123 # Remove any OVERDUES related debarment if the borrower has no overdues
3125 && $patron->is_debarred
3126 && ! $patron->has_overdues
3127 && @{ GetDebarments({ borrowernumber => $borrowernumber, type => 'OVERDUES' }) }
3129 DelUniqueDebarment({ borrowernumber => $borrowernumber, type => 'OVERDUES' });
3132 # Add the renewal to stats
3135 branch => $item_object->renewal_branchcode({branch => $branch}),
3138 itemnumber => $itemnumber,
3139 itemtype => $itemtype,
3140 location => $item_object->location,
3141 borrowernumber => $borrowernumber,
3142 ccode => $item_object->ccode,
3147 logaction("CIRCULATION", "RENEWAL", $borrowernumber, $itemnumber) if C4::Context->preference("RenewalLog");
3149 _after_circ_actions(
3151 action => 'renewal',
3153 checkout => $issue->get_from_storage
3156 ) if C4::Context->config("enable_plugins");
3163 # check renewal status
3164 my ( $bornum, $itemno ) = @_;
3165 my $dbh = C4::Context->dbh;
3167 my $renewsallowed = 0;
3170 my $patron = Koha::Patrons->find( $bornum );
3171 my $item = Koha::Items->find($itemno);
3173 return (0, 0, 0) unless $patron or $item; # Wrong call, no renewal allowed
3175 # Look in the issues table for this item, lent to this borrower,
3176 # and not yet returned.
3178 # FIXME - I think this function could be redone to use only one SQL call.
3179 my $sth = $dbh->prepare(
3180 "select * from issues
3181 where (borrowernumber = ?)
3182 and (itemnumber = ?)"
3184 $sth->execute( $bornum, $itemno );
3185 my $data = $sth->fetchrow_hashref;
3186 $renewcount = $data->{'renewals'} if $data->{'renewals'};
3187 # $item and $borrower should be calculated
3188 my $branchcode = _GetCircControlBranch($item->unblessed, $patron->unblessed);
3190 my $rule = Koha::CirculationRules->get_effective_rule(
3192 categorycode => $patron->categorycode,
3193 itemtype => $item->effective_itemtype,
3194 branchcode => $branchcode,
3195 rule_name => 'renewalsallowed',
3199 $renewsallowed = $rule ? $rule->rule_value : 0;
3200 $renewsleft = $renewsallowed - $renewcount;
3201 if($renewsleft < 0){ $renewsleft = 0; }
3202 return ( $renewcount, $renewsallowed, $renewsleft );
3205 =head2 GetSoonestRenewDate
3207 $NoRenewalBeforeThisDate = &GetSoonestRenewDate($borrowernumber, $itemnumber);
3209 Find out the soonest possible renew date of a borrowed item.
3211 C<$borrowernumber> is the borrower number of the patron who currently
3212 has the item on loan.
3214 C<$itemnumber> is the number of the item to renew.
3216 C<$GetSoonestRenewDate> returns the DateTime of the soonest possible
3217 renew date, based on the value "No renewal before" of the applicable
3218 issuing rule. Returns the current date if the item can already be
3219 renewed, and returns undefined if the borrower, loan, or item
3224 sub GetSoonestRenewDate {
3225 my ( $borrowernumber, $itemnumber ) = @_;
3227 my $dbh = C4::Context->dbh;
3229 my $item = Koha::Items->find($itemnumber) or return;
3230 my $itemissue = $item->checkout or return;
3232 $borrowernumber ||= $itemissue->borrowernumber;
3233 my $patron = Koha::Patrons->find( $borrowernumber )
3236 my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
3237 my $issuing_rule = Koha::CirculationRules->get_effective_rules(
3238 { categorycode => $patron->categorycode,
3239 itemtype => $item->effective_itemtype,
3240 branchcode => $branchcode,
3248 my $now = dt_from_string;
3249 return $now unless $issuing_rule;
3251 if ( defined $issuing_rule->{norenewalbefore}
3252 and $issuing_rule->{norenewalbefore} ne "" )
3254 my $soonestrenewal =
3255 dt_from_string( $itemissue->date_due )->subtract(
3256 $issuing_rule->{lengthunit} => $issuing_rule->{norenewalbefore} );
3258 if ( C4::Context->preference('NoRenewalBeforePrecision') eq 'date'
3259 and $issuing_rule->{lengthunit} eq 'days' )
3261 $soonestrenewal->truncate( to => 'day' );
3263 return $soonestrenewal if $now < $soonestrenewal;
3268 =head2 GetLatestAutoRenewDate
3270 $NoAutoRenewalAfterThisDate = &GetLatestAutoRenewDate($borrowernumber, $itemnumber);
3272 Find out the latest possible auto renew date of a borrowed item.
3274 C<$borrowernumber> is the borrower number of the patron who currently
3275 has the item on loan.
3277 C<$itemnumber> is the number of the item to renew.
3279 C<$GetLatestAutoRenewDate> returns the DateTime of the latest possible
3280 auto renew date, based on the value "No auto renewal after" and the "No auto
3281 renewal after (hard limit) of the applicable issuing rule.
3282 Returns undef if there is no date specify in the circ rules or if the patron, loan,
3283 or item cannot be found.
3287 sub GetLatestAutoRenewDate {
3288 my ( $borrowernumber, $itemnumber ) = @_;
3290 my $dbh = C4::Context->dbh;
3292 my $item = Koha::Items->find($itemnumber) or return;
3293 my $itemissue = $item->checkout or return;
3295 $borrowernumber ||= $itemissue->borrowernumber;
3296 my $patron = Koha::Patrons->find( $borrowernumber )
3299 my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
3300 my $circulation_rules = Koha::CirculationRules->get_effective_rules(
3302 categorycode => $patron->categorycode,
3303 itemtype => $item->effective_itemtype,
3304 branchcode => $branchcode,
3306 'no_auto_renewal_after',
3307 'no_auto_renewal_after_hard_limit',
3313 return unless $circulation_rules;
3315 if ( not $circulation_rules->{no_auto_renewal_after}
3316 or $circulation_rules->{no_auto_renewal_after} eq '' )
3317 and ( not $circulation_rules->{no_auto_renewal_after_hard_limit}
3318 or $circulation_rules->{no_auto_renewal_after_hard_limit} eq '' );
3320 my $maximum_renewal_date;
3321 if ( $circulation_rules->{no_auto_renewal_after} ) {
3322 $maximum_renewal_date = dt_from_string($itemissue->issuedate);
3323 $maximum_renewal_date->add(
3324 $circulation_rules->{lengthunit} => $circulation_rules->{no_auto_renewal_after}
3328 if ( $circulation_rules->{no_auto_renewal_after_hard_limit} ) {
3329 my $dt = dt_from_string( $circulation_rules->{no_auto_renewal_after_hard_limit} );
3330 $maximum_renewal_date = $dt if not $maximum_renewal_date or $maximum_renewal_date > $dt;
3332 return $maximum_renewal_date;
3336 =head2 GetIssuingCharges
3338 ($charge, $item_type) = &GetIssuingCharges($itemnumber, $borrowernumber);
3340 Calculate how much it would cost for a given patron to borrow a given
3341 item, including any applicable discounts.
3343 C<$itemnumber> is the item number of item the patron wishes to borrow.
3345 C<$borrowernumber> is the patron's borrower number.
3347 C<&GetIssuingCharges> returns two values: C<$charge> is the rental charge,
3348 and C<$item_type> is the code for the item's item type (e.g., C<VID>
3353 sub GetIssuingCharges {
3355 # calculate charges due
3356 my ( $itemnumber, $borrowernumber ) = @_;
3358 my $dbh = C4::Context->dbh;
3361 # Get the book's item type and rental charge (via its biblioitem).
3362 my $charge_query = 'SELECT itemtypes.itemtype,rentalcharge FROM items
3363 LEFT JOIN biblioitems ON biblioitems.biblioitemnumber = items.biblioitemnumber';
3364 $charge_query .= (C4::Context->preference('item-level_itypes'))
3365 ? ' LEFT JOIN itemtypes ON items.itype = itemtypes.itemtype'
3366 : ' LEFT JOIN itemtypes ON biblioitems.itemtype = itemtypes.itemtype';
3368 $charge_query .= ' WHERE items.itemnumber =?';
3370 my $sth = $dbh->prepare($charge_query);
3371 $sth->execute($itemnumber);
3372 if ( my $item_data = $sth->fetchrow_hashref ) {
3373 $item_type = $item_data->{itemtype};
3374 $charge = $item_data->{rentalcharge};
3375 my $branch = C4::Context::mybranch();
3376 my $patron = Koha::Patrons->find( $borrowernumber );
3377 my $discount = _get_discount_from_rule($patron->categorycode, $branch, $item_type);
3379 # We may have multiple rules so get the most specific
3380 $charge = ( $charge * ( 100 - $discount ) ) / 100;
3383 $charge = sprintf '%.2f', $charge; # ensure no fractions of a penny returned
3387 return ( $charge, $item_type );
3390 # Select most appropriate discount rule from those returned
3391 sub _get_discount_from_rule {
3392 my ($categorycode, $branchcode, $itemtype) = @_;
3394 # Set search precedences
3397 branchcode => $branchcode,
3398 itemtype => $itemtype,
3399 categorycode => $categorycode,
3402 branchcode => undef,
3403 categorycode => $categorycode,
3404 itemtype => $itemtype,
3407 branchcode => $branchcode,
3408 categorycode => $categorycode,
3412 branchcode => undef,
3413 categorycode => $categorycode,
3418 foreach my $params (@params) {
3419 my $rule = Koha::CirculationRules->search(
3421 rule_name => 'rentaldiscount',
3426 return $rule->rule_value if $rule;
3433 =head2 AddIssuingCharge
3435 &AddIssuingCharge( $checkout, $charge, $type )
3439 sub AddIssuingCharge {
3440 my ( $checkout, $charge, $type ) = @_;
3442 # FIXME What if checkout does not exist?
3444 my $account = Koha::Account->new({ patron_id => $checkout->borrowernumber });
3445 my $accountline = $account->add_debit(
3449 user_id => C4::Context->userenv ? C4::Context->userenv->{'number'} : undef,
3450 library_id => C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef,
3451 interface => C4::Context->interface,
3453 item_id => $checkout->itemnumber,
3454 issue_id => $checkout->issue_id,
3461 GetTransfers($itemnumber);
3466 my ($itemnumber) = @_;
3468 my $dbh = C4::Context->dbh;
3475 FROM branchtransfers
3476 WHERE itemnumber = ?
3477 AND datearrived IS NULL
3479 my $sth = $dbh->prepare($query);
3480 $sth->execute($itemnumber);
3481 my @row = $sth->fetchrow_array();
3485 =head2 GetTransfersFromTo
3487 @results = GetTransfersFromTo($frombranch,$tobranch);
3489 Returns the list of pending transfers between $from and $to branch
3493 sub GetTransfersFromTo {
3494 my ( $frombranch, $tobranch ) = @_;
3495 return unless ( $frombranch && $tobranch );
3496 my $dbh = C4::Context->dbh;
3498 SELECT branchtransfer_id,itemnumber,datesent,frombranch
3499 FROM branchtransfers
3502 AND datearrived IS NULL
3504 my $sth = $dbh->prepare($query);
3505 $sth->execute( $frombranch, $tobranch );
3508 while ( my $data = $sth->fetchrow_hashref ) {
3509 push @gettransfers, $data;
3511 return (@gettransfers);
3514 =head2 DeleteTransfer
3516 &DeleteTransfer($itemnumber);
3520 sub DeleteTransfer {
3521 my ($itemnumber) = @_;
3522 return unless $itemnumber;
3523 my $dbh = C4::Context->dbh;
3524 my $sth = $dbh->prepare(
3525 "DELETE FROM branchtransfers
3527 AND datearrived IS NULL "
3529 return $sth->execute($itemnumber);
3532 =head2 SendCirculationAlert
3534 Send out a C<check-in> or C<checkout> alert using the messaging system.
3542 Valid values for this parameter are: C<CHECKIN> and C<CHECKOUT>.
3546 Hashref of information about the item being checked in or out.
3550 Hashref of information about the borrower of the item.
3554 The branchcode from where the checkout or check-in took place.
3560 SendCirculationAlert({
3563 borrower => $borrower,
3569 sub SendCirculationAlert {
3571 my ($type, $item, $borrower, $branch) =
3572 ($opts->{type}, $opts->{item}, $opts->{borrower}, $opts->{branch});
3573 my %message_name = (
3574 CHECKIN => 'Item_Check_in',
3575 CHECKOUT => 'Item_Checkout',
3576 RENEWAL => 'Item_Checkout',
3578 my $borrower_preferences = C4::Members::Messaging::GetMessagingPreferences({
3579 borrowernumber => $borrower->{borrowernumber},
3580 message_name => $message_name{$type},
3582 my $issues_table = ( $type eq 'CHECKOUT' || $type eq 'RENEWAL' ) ? 'issues' : 'old_issues';
3584 my $schema = Koha::Database->new->schema;
3585 my @transports = keys %{ $borrower_preferences->{transports} };
3587 # From the MySQL doc:
3588 # LOCK TABLES is not transaction-safe and implicitly commits any active transaction before attempting to lock the tables.
3589 # If the LOCK/UNLOCK statements are executed from tests, the current transaction will be committed.
3590 # To avoid that we need to guess if this code is execute from tests or not (yes it is a bit hacky)
3591 my $do_not_lock = ( exists $ENV{_} && $ENV{_} =~ m|prove| ) || $ENV{KOHA_TESTING};
3593 for my $mtt (@transports) {
3594 my $letter = C4::Letters::GetPreparedLetter (
3595 module => 'circulation',
3596 letter_code => $type,
3597 branchcode => $branch,
3598 message_transport_type => $mtt,
3599 lang => $borrower->{lang},
3601 $issues_table => $item->{itemnumber},
3602 'items' => $item->{itemnumber},
3603 'biblio' => $item->{biblionumber},
3604 'biblioitems' => $item->{biblionumber},
3605 'borrowers' => $borrower,
3606 'branches' => $branch,
3610 $schema->storage->txn_begin;
3611 C4::Context->dbh->do(q|LOCK TABLE message_queue READ|) unless $do_not_lock;
3612 C4::Context->dbh->do(q|LOCK TABLE message_queue WRITE|) unless $do_not_lock;
3613 my $message = C4::Message->find_last_message($borrower, $type, $mtt);
3614 unless ( $message ) {
3615 C4::Context->dbh->do(q|UNLOCK TABLES|) unless $do_not_lock;
3616 C4::Message->enqueue($letter, $borrower, $mtt);
3618 $message->append($letter);
3621 C4::Context->dbh->do(q|UNLOCK TABLES|) unless $do_not_lock;
3622 $schema->storage->txn_commit;
3628 =head2 updateWrongTransfer
3630 $items = updateWrongTransfer($itemNumber,$borrowernumber,$waitingAtLibrary,$FromLibrary);
3632 This function validate the line of brachtransfer but with the wrong destination (mistake from a librarian ...), and create a new line in branchtransfer from the actual library to the original library of reservation
3636 sub updateWrongTransfer {
3637 my ( $itemNumber,$waitingAtLibrary,$FromLibrary ) = @_;
3638 my $dbh = C4::Context->dbh;
3639 # first step validate the actual line of transfert .
3642 "update branchtransfers set datearrived = now(),tobranch=?,comments='wrongtransfer' where itemnumber= ? AND datearrived IS NULL"
3644 $sth->execute($FromLibrary,$itemNumber);
3646 # second step create a new line of branchtransfer to the right location .
3647 ModItemTransfer($itemNumber, $FromLibrary, $waitingAtLibrary);
3649 #third step changing holdingbranch of item
3650 my $item = Koha::Items->find($itemNumber)->holdingbranch($FromLibrary)->store;
3655 $newdatedue = CalcDateDue($startdate,$itemtype,$branchcode,$borrower);
3657 this function calculates the due date given the start date and configured circulation rules,
3658 checking against the holidays calendar as per the daysmode circulation rule.
3659 C<$startdate> = DateTime object representing start date of loan period (assumed to be today)
3660 C<$itemtype> = itemtype code of item in question
3661 C<$branch> = location whose calendar to use
3662 C<$borrower> = Borrower object
3663 C<$isrenewal> = Boolean: is true if we want to calculate the date due for a renewal. Else is false.
3668 my ( $startdate, $itemtype, $branch, $borrower, $isrenewal ) = @_;
3672 # loanlength now a href
3674 GetLoanLength( $borrower->{'categorycode'}, $itemtype, $branch );
3676 my $length_key = ( $isrenewal and defined $loanlength->{renewalperiod} )
3682 if (ref $startdate ne 'DateTime' ) {
3683 $datedue = dt_from_string($datedue);
3685 $datedue = $startdate->clone;
3688 $datedue = dt_from_string()->truncate( to => 'minute' );
3692 my $daysmode = Koha::CirculationRules->get_effective_daysmode(
3694 categorycode => $borrower->{categorycode},
3695 itemtype => $itemtype,
3696 branchcode => $branch,
3700 # calculate the datedue as normal
3701 if ( $daysmode eq 'Days' )
3702 { # ignoring calendar
3703 if ( $loanlength->{lengthunit} eq 'hours' ) {
3704 $datedue->add( hours => $loanlength->{$length_key} );
3706 $datedue->add( days => $loanlength->{$length_key} );
3707 $datedue->set_hour(23);
3708 $datedue->set_minute(59);
3712 if ($loanlength->{lengthunit} eq 'hours') {
3713 $dur = DateTime::Duration->new( hours => $loanlength->{$length_key});
3716 $dur = DateTime::Duration->new( days => $loanlength->{$length_key});
3718 my $calendar = Koha::Calendar->new( branchcode => $branch, days_mode => $daysmode );
3719 $datedue = $calendar->addDate( $datedue, $dur, $loanlength->{lengthunit} );
3720 if ($loanlength->{lengthunit} eq 'days') {
3721 $datedue->set_hour(23);
3722 $datedue->set_minute(59);
3726 # if Hard Due Dates are used, retrieve them and apply as necessary
3727 my ( $hardduedate, $hardduedatecompare ) =
3728 GetHardDueDate( $borrower->{'categorycode'}, $itemtype, $branch );
3729 if ($hardduedate) { # hardduedates are currently dates
3730 $hardduedate->truncate( to => 'minute' );
3731 $hardduedate->set_hour(23);
3732 $hardduedate->set_minute(59);
3733 my $cmp = DateTime->compare( $hardduedate, $datedue );
3735 # if the calculated due date is after the 'before' Hard Due Date (ceiling), override
3736 # if the calculated date is before the 'after' Hard Due Date (floor), override
3737 # if the hard due date is set to 'exactly', overrride
3738 if ( $hardduedatecompare == 0 || $hardduedatecompare == $cmp ) {
3739 $datedue = $hardduedate->clone;
3742 # in all other cases, keep the date due as it is
3746 # if ReturnBeforeExpiry ON the datedue can't be after borrower expirydate
3747 if ( C4::Context->preference('ReturnBeforeExpiry') ) {
3748 my $expiry_dt = dt_from_string( $borrower->{dateexpiry}, 'iso', 'floating');
3749 if( $expiry_dt ) { #skip empty expiry date..
3750 $expiry_dt->set( hour => 23, minute => 59);
3751 my $d1= $datedue->clone->set_time_zone('floating');
3752 if ( DateTime->compare( $d1, $expiry_dt ) == 1 ) {
3753 $datedue = $expiry_dt->clone->set_time_zone( C4::Context->tz );
3756 if ( $daysmode ne 'Days' ) {
3757 my $calendar = Koha::Calendar->new( branchcode => $branch, days_mode => $daysmode );
3758 if ( $calendar->is_holiday($datedue) ) {
3759 # Don't return on a closed day
3760 $datedue = $calendar->prev_open_days( $datedue, 1 );
3769 sub CheckValidBarcode{
3771 my $dbh = C4::Context->dbh;
3772 my $query=qq|SELECT count(*)
3776 my $sth = $dbh->prepare($query);
3777 $sth->execute($barcode);
3778 my $exist=$sth->fetchrow ;
3782 =head2 IsBranchTransferAllowed
3784 $allowed = IsBranchTransferAllowed( $toBranch, $fromBranch, $code );
3786 Code is either an itemtype or collection doe depending on the pref BranchTransferLimitsType
3788 Deprecated in favor of Koha::Item::Transfer::Limits->find/search and
3789 Koha::Item->can_be_transferred.
3793 sub IsBranchTransferAllowed {
3794 my ( $toBranch, $fromBranch, $code ) = @_;
3796 if ( $toBranch eq $fromBranch ) { return 1; } ## Short circuit for speed.
3798 my $limitType = C4::Context->preference("BranchTransferLimitsType");
3799 my $dbh = C4::Context->dbh;
3801 my $sth = $dbh->prepare("SELECT * FROM branch_transfer_limits WHERE toBranch = ? AND fromBranch = ? AND $limitType = ?");
3802 $sth->execute( $toBranch, $fromBranch, $code );
3803 my $limit = $sth->fetchrow_hashref();
3805 ## If a row is found, then that combination is not allowed, if no matching row is found, then the combination *is allowed*
3806 if ( $limit->{'limitId'} ) {
3813 =head2 CreateBranchTransferLimit
3815 CreateBranchTransferLimit( $toBranch, $fromBranch, $code );
3817 $code is either itemtype or collection code depending on what the pref BranchTransferLimitsType is set to.
3819 Deprecated in favor of Koha::Item::Transfer::Limit->new.
3823 sub CreateBranchTransferLimit {
3824 my ( $toBranch, $fromBranch, $code ) = @_;
3825 return unless defined($toBranch) && defined($fromBranch);
3826 my $limitType = C4::Context->preference("BranchTransferLimitsType");
3828 my $dbh = C4::Context->dbh;
3830 my $sth = $dbh->prepare("INSERT INTO branch_transfer_limits ( $limitType, toBranch, fromBranch ) VALUES ( ?, ?, ? )");
3831 return $sth->execute( $code, $toBranch, $fromBranch );
3834 =head2 DeleteBranchTransferLimits
3836 my $result = DeleteBranchTransferLimits($frombranch);
3838 Deletes all the library transfer limits for one library. Returns the
3839 number of limits deleted, 0e0 if no limits were deleted, or undef if
3840 no arguments are supplied.
3842 Deprecated in favor of Koha::Item::Transfer::Limits->search({
3843 fromBranch => $fromBranch
3848 sub DeleteBranchTransferLimits {
3850 return unless defined $branch;
3851 my $dbh = C4::Context->dbh;
3852 my $sth = $dbh->prepare("DELETE FROM branch_transfer_limits WHERE fromBranch = ?");
3853 return $sth->execute($branch);
3857 my ( $borrowernumber, $itemnum ) = @_;
3858 MarkIssueReturned( $borrowernumber, $itemnum );
3863 my ($itemnumber, $mark_lost_from, $force_mark_returned) = @_;
3865 unless ( $mark_lost_from ) {
3866 # Temporary check to avoid regressions
3867 die q|LostItem called without $mark_lost_from, check the API.|;
3871 if ( $force_mark_returned ) {
3874 my $pref = C4::Context->preference('MarkLostItemsAsReturned') // q{};
3875 $mark_returned = ( $pref =~ m|$mark_lost_from| );
3878 my $dbh = C4::Context->dbh();
3879 my $sth=$dbh->prepare("SELECT issues.*,items.*,biblio.title
3881 JOIN items USING (itemnumber)
3882 JOIN biblio USING (biblionumber)
3883 WHERE issues.itemnumber=?");
3884 $sth->execute($itemnumber);
3885 my $issues=$sth->fetchrow_hashref();
3887 # If a borrower lost the item, add a replacement cost to the their record
3888 if ( my $borrowernumber = $issues->{borrowernumber} ){
3889 my $patron = Koha::Patrons->find( $borrowernumber );
3891 my $fix = _FixOverduesOnReturn($borrowernumber, $itemnumber, C4::Context->preference('WhenLostForgiveFine'), 'LOST');
3892 defined($fix) or warn "_FixOverduesOnReturn($borrowernumber, $itemnumber...) failed!"; # zero is OK, check defined
3894 if (C4::Context->preference('WhenLostChargeReplacementFee')){
3895 C4::Accounts::chargelostitem(
3898 $issues->{'replacementprice'},
3899 sprintf( "%s %s %s",
3900 $issues->{'title'} || q{},
3901 $issues->{'barcode'} || q{},
3902 $issues->{'itemcallnumber'} || q{},
3905 #FIXME : Should probably have a way to distinguish this from an item that really was returned.
3906 #warn " $issues->{'borrowernumber'} / $itemnumber ";
3909 MarkIssueReturned($borrowernumber,$itemnumber,undef,$patron->privacy) if $mark_returned;
3912 #When item is marked lost automatically cancel its outstanding transfers and set items holdingbranch to the transfer source branch (frombranch)
3913 if (my ( $datesent,$frombranch,$tobranch ) = GetTransfers($itemnumber)) {
3914 Koha::Items->find($itemnumber)->holdingbranch($frombranch)->store;
3916 my $transferdeleted = DeleteTransfer($itemnumber);
3919 sub GetOfflineOperations {
3920 my $dbh = C4::Context->dbh;
3921 my $sth = $dbh->prepare("SELECT * FROM pending_offline_operations WHERE branchcode=? ORDER BY timestamp");
3922 $sth->execute(C4::Context->userenv->{'branch'});
3923 my $results = $sth->fetchall_arrayref({});
3927 sub GetOfflineOperation {
3928 my $operationid = shift;
3929 return unless $operationid;
3930 my $dbh = C4::Context->dbh;
3931 my $sth = $dbh->prepare("SELECT * FROM pending_offline_operations WHERE operationid=?");
3932 $sth->execute( $operationid );
3933 return $sth->fetchrow_hashref;
3936 sub AddOfflineOperation {
3937 my ( $userid, $branchcode, $timestamp, $action, $barcode, $cardnumber, $amount ) = @_;
3938 my $dbh = C4::Context->dbh;
3939 my $sth = $dbh->prepare("INSERT INTO pending_offline_operations (userid, branchcode, timestamp, action, barcode, cardnumber, amount) VALUES(?,?,?,?,?,?,?)");
3940 $sth->execute( $userid, $branchcode, $timestamp, $action, $barcode, $cardnumber, $amount );
3944 sub DeleteOfflineOperation {
3945 my $dbh = C4::Context->dbh;
3946 my $sth = $dbh->prepare("DELETE FROM pending_offline_operations WHERE operationid=?");
3947 $sth->execute( shift );
3951 sub ProcessOfflineOperation {
3952 my $operation = shift;
3955 if ( $operation->{action} eq 'return' ) {
3956 $report = ProcessOfflineReturn( $operation );
3957 } elsif ( $operation->{action} eq 'issue' ) {
3958 $report = ProcessOfflineIssue( $operation );
3959 } elsif ( $operation->{action} eq 'payment' ) {
3960 $report = ProcessOfflinePayment( $operation );
3963 DeleteOfflineOperation( $operation->{operationid} ) if $operation->{operationid};
3968 sub ProcessOfflineReturn {
3969 my $operation = shift;
3971 my $item = Koha::Items->find({barcode => $operation->{barcode}});
3974 my $itemnumber = $item->itemnumber;
3975 my $issue = GetOpenIssue( $itemnumber );
3977 my $leave_item_lost = C4::Context->preference("BlockReturnOfLostItems") ? 1 : 0;
3978 ModDateLastSeen( $itemnumber, $leave_item_lost );
3980 $issue->{borrowernumber},
3982 $operation->{timestamp},
3985 $item->onloan(undef);
3986 $item->store({ log_action => 0 });
3989 return "Item not issued.";
3992 return "Item not found.";
3996 sub ProcessOfflineIssue {
3997 my $operation = shift;
3999 my $patron = Koha::Patrons->find( { cardnumber => $operation->{cardnumber} } );
4002 my $item = Koha::Items->find({ barcode => $operation->{barcode} });
4004 return "Barcode not found.";
4006 my $itemnumber = $item->itemnumber;
4007 my $issue = GetOpenIssue( $itemnumber );
4009 if ( $issue and ( $issue->{borrowernumber} ne $patron->borrowernumber ) ) { # Item already issued to another patron mark it returned
4011 $issue->{borrowernumber},
4013 $operation->{timestamp},
4018 $operation->{'barcode'},
4021 $operation->{timestamp},
4026 return "Borrower not found.";
4030 sub ProcessOfflinePayment {
4031 my $operation = shift;
4033 my $patron = Koha::Patrons->find({ cardnumber => $operation->{cardnumber} });
4035 $patron->account->pay(
4037 amount => $operation->{amount},
4038 library_id => $operation->{branchcode},
4048 TransferSlip($user_branch, $itemnumber, $barcode, $to_branch)
4050 Returns letter hash ( see C4::Letters::GetPreparedLetter ) or undef
4055 my ($branch, $itemnumber, $barcode, $to_branch) = @_;
4059 ? Koha::Items->find($itemnumber)
4060 : Koha::Items->find( { barcode => $barcode } );
4064 return C4::Letters::GetPreparedLetter (
4065 module => 'circulation',
4066 letter_code => 'TRANSFERSLIP',
4067 branchcode => $branch,
4069 'branches' => $to_branch,
4070 'biblio' => $item->biblionumber,
4071 'items' => $item->unblessed,
4076 =head2 CheckIfIssuedToPatron
4078 CheckIfIssuedToPatron($borrowernumber, $biblionumber)
4080 Return 1 if any record item is issued to patron, otherwise return 0
4084 sub CheckIfIssuedToPatron {
4085 my ($borrowernumber, $biblionumber) = @_;
4087 my $dbh = C4::Context->dbh;
4089 SELECT COUNT(*) FROM issues
4090 LEFT JOIN items ON items.itemnumber = issues.itemnumber
4091 WHERE items.biblionumber = ?
4092 AND issues.borrowernumber = ?
4094 my $is_issued = $dbh->selectrow_array($query, {}, $biblionumber, $borrowernumber );
4095 return 1 if $is_issued;
4101 IsItemIssued( $itemnumber )
4103 Return 1 if the item is on loan, otherwise return 0
4108 my $itemnumber = shift;
4109 my $dbh = C4::Context->dbh;
4110 my $sth = $dbh->prepare(q{
4113 WHERE itemnumber = ?
4115 $sth->execute($itemnumber);
4116 return $sth->fetchrow;
4119 =head2 GetAgeRestriction
4121 my ($ageRestriction, $daysToAgeRestriction) = GetAgeRestriction($record_restrictions, $borrower);
4122 my ($ageRestriction, $daysToAgeRestriction) = GetAgeRestriction($record_restrictions);
4124 if($daysToAgeRestriction <= 0) { #Borrower is allowed to access this material, as they are older or as old as the agerestriction }
4125 if($daysToAgeRestriction > 0) { #Borrower is this many days from meeting the agerestriction }
4127 @PARAM1 the koha.biblioitems.agerestriction value, like K18, PEGI 13, ...
4128 @PARAM2 a borrower-object with koha.borrowers.dateofbirth. (OPTIONAL)
4129 @RETURNS The age restriction age in years and the days to fulfill the age restriction for the given borrower.
4130 Negative days mean the borrower has gone past the age restriction age.
4134 sub GetAgeRestriction {
4135 my ($record_restrictions, $borrower) = @_;
4136 my $markers = C4::Context->preference('AgeRestrictionMarker');
4138 return unless $record_restrictions;
4139 # Split $record_restrictions to something like FSK 16 or PEGI 6
4140 my @values = split ' ', uc($record_restrictions);
4141 return unless @values;
4143 # Search first occurrence of one of the markers
4144 my @markers = split /\|/, uc($markers);
4145 return unless @markers;
4148 my $restriction_year = 0;
4149 for my $value (@values) {
4151 for my $marker (@markers) {
4152 $marker =~ s/^\s+//; #remove leading spaces
4153 $marker =~ s/\s+$//; #remove trailing spaces
4154 if ( $marker eq $value ) {
4155 if ( $index <= $#values ) {
4156 $restriction_year += $values[$index];
4160 elsif ( $value =~ /^\Q$marker\E(\d+)$/ ) {
4162 # Perhaps it is something like "K16" (as in Finland)
4163 $restriction_year += $1;
4167 last if ( $restriction_year > 0 );
4170 #Check if the borrower is age restricted for this material and for how long.
4171 if ($restriction_year && $borrower) {
4172 if ( $borrower->{'dateofbirth'} ) {
4173 my @alloweddate = split /-/, $borrower->{'dateofbirth'};
4174 $alloweddate[0] += $restriction_year;
4176 #Prevent runime eror on leap year (invalid date)
4177 if ( ( $alloweddate[1] == 2 ) && ( $alloweddate[2] == 29 ) ) {
4178 $alloweddate[2] = 28;
4181 #Get how many days the borrower has to reach the age restriction
4182 my @Today = split /-/, dt_from_string()->ymd();
4183 my $daysToAgeRestriction = Date_to_Days(@alloweddate) - Date_to_Days(@Today);
4184 #Negative days means the borrower went past the age restriction age
4185 return ($restriction_year, $daysToAgeRestriction);
4189 return ($restriction_year);
4193 =head2 GetPendingOnSiteCheckouts
4197 sub GetPendingOnSiteCheckouts {
4198 my $dbh = C4::Context->dbh;
4199 return $dbh->selectall_arrayref(q|
4205 items.itemcallnumber,
4209 issues.date_due < NOW() AS is_overdue,
4212 borrowers.firstname,
4214 borrowers.cardnumber,
4215 borrowers.borrowernumber
4217 LEFT JOIN issues ON items.itemnumber = issues.itemnumber
4218 LEFT JOIN biblio ON items.biblionumber = biblio.biblionumber
4219 LEFT JOIN borrowers ON issues.borrowernumber = borrowers.borrowernumber
4220 WHERE issues.onsite_checkout = 1
4221 |, { Slice => {} } );
4227 my ($count, $branch, $itemtype, $ccode, $newness)
4228 = @$params{qw(count branch itemtype ccode newness)};
4230 my $dbh = C4::Context->dbh;
4233 SELECT b.biblionumber, b.title, b.author, bi.itemtype, bi.publishercode,
4234 bi.place, bi.publicationyear, b.copyrightdate, bi.pages, bi.size,
4235 i.ccode, SUM(i.issues) AS count
4237 LEFT JOIN items i ON (i.biblionumber = b.biblionumber)
4238 LEFT JOIN biblioitems bi ON (bi.biblionumber = b.biblionumber)
4241 my (@where_strs, @where_args);
4244 push @where_strs, 'i.homebranch = ?';
4245 push @where_args, $branch;
4248 if (C4::Context->preference('item-level_itypes')){
4249 push @where_strs, 'i.itype = ?';
4250 push @where_args, $itemtype;
4252 push @where_strs, 'bi.itemtype = ?';
4253 push @where_args, $itemtype;
4257 push @where_strs, 'i.ccode = ?';
4258 push @where_args, $ccode;
4261 push @where_strs, 'TO_DAYS(NOW()) - TO_DAYS(b.datecreated) <= ?';
4262 push @where_args, $newness;
4266 $query .= 'WHERE ' . join(' AND ', @where_strs);
4270 GROUP BY b.biblionumber, b.title, b.author, bi.itemtype, bi.publishercode,
4271 bi.place, bi.publicationyear, b.copyrightdate, bi.pages, bi.size,
4276 $query .= q{ ) xxx WHERE count > 0 };
4277 $count = int($count);
4279 $query .= "LIMIT $count";
4282 my $rows = $dbh->selectall_arrayref($query, { Slice => {} }, @where_args);
4287 =head2 Internal methods
4291 sub _CalculateAndUpdateFine {
4294 my $borrower = $params->{borrower};
4295 my $item = $params->{item};
4296 my $issue = $params->{issue};
4297 my $return_date = $params->{return_date};
4299 unless ($borrower) { carp "No borrower passed in!" && return; }
4300 unless ($item) { carp "No item passed in!" && return; }
4301 unless ($issue) { carp "No issue passed in!" && return; }
4303 my $datedue = dt_from_string( $issue->date_due );
4305 # we only need to calculate and change the fines if we want to do that on return
4306 # Should be on for hourly loans
4307 my $control = C4::Context->preference('CircControl');
4308 my $control_branchcode =
4309 ( $control eq 'ItemHomeLibrary' ) ? $item->{homebranch}
4310 : ( $control eq 'PatronLibrary' ) ? $borrower->{branchcode}
4311 : $issue->branchcode;
4313 my $date_returned = $return_date ? $return_date : dt_from_string();
4315 my ( $amount, $unitcounttotal, $unitcount ) =
4316 C4::Overdues::CalcFine( $item, $borrower->{categorycode}, $control_branchcode, $datedue, $date_returned );
4318 if ( C4::Context->preference('finesMode') eq 'production' ) {
4319 if ( $amount > 0 ) {
4320 C4::Overdues::UpdateFine({
4321 issue_id => $issue->issue_id,
4322 itemnumber => $issue->itemnumber,
4323 borrowernumber => $issue->borrowernumber,
4325 due => output_pref($datedue),
4328 elsif ($return_date) {
4330 # Backdated returns may have fines that shouldn't exist,
4331 # so in this case, we need to drop those fines to 0
4333 C4::Overdues::UpdateFine({
4334 issue_id => $issue->issue_id,
4335 itemnumber => $issue->itemnumber,
4336 borrowernumber => $issue->borrowernumber,
4338 due => output_pref($datedue),
4344 sub _item_denied_renewal {
4347 my $item = $params->{item};
4348 return unless $item;
4350 my $denyingrules = Koha::Config::SysPrefs->find('ItemsDeniedRenewal')->get_yaml_pref_hash();
4351 return unless $denyingrules;
4352 foreach my $field (keys %$denyingrules) {
4353 my $val = $item->$field;
4354 if( !defined $val) {
4355 if ( any { !defined $_ } @{$denyingrules->{$field}} ){
4358 } elsif (any { defined($_) && $val eq $_ } @{$denyingrules->{$field}}) {
4359 # If the results matches the values in the syspref
4360 # We return true if match found
4367 =head3 _after_circ_actions
4369 Internal method that calls the after_circ_action plugin hook on configured
4374 sub _after_circ_actions {
4377 my @plugins = Koha::Plugins->new->GetPlugins({
4378 method => 'after_circ_action',
4381 foreach my $plugin ( @plugins ) {
4383 $plugin->after_circ_action( $params );
4397 Koha Development Team <http://koha-community.org/>