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 # Record the fact that this book was issued.
1515 branch => C4::Context->userenv->{'branch'},
1516 type => ( $onsite_checkout ? 'onsite_checkout' : 'issue' ),
1518 other => ( $sipmode ? "SIP-$sipmode" : '' ),
1519 itemnumber => $item_object->itemnumber,
1520 itemtype => $item_object->effective_itemtype,
1521 location => $item_object->location,
1522 borrowernumber => $borrower->{'borrowernumber'},
1523 ccode => $item_object->ccode,
1527 # Send a checkout slip.
1528 my $circulation_alert = 'C4::ItemCirculationAlertPreference';
1530 branchcode => $branchcode,
1531 categorycode => $borrower->{categorycode},
1532 item_type => $item_object->effective_itemtype,
1533 notification => 'CHECKOUT',
1535 if ( $circulation_alert->is_enabled_for( \%conditions ) ) {
1536 SendCirculationAlert(
1539 item => $item_object->unblessed,
1540 borrower => $borrower,
1541 branch => $branchcode,
1546 "CIRCULATION", "ISSUE",
1547 $borrower->{'borrowernumber'},
1548 $item_object->itemnumber,
1549 ) if C4::Context->preference("IssueLog");
1551 _after_circ_actions(
1553 action => 'checkout',
1555 type => ( $onsite_checkout ? 'onsite_checkout' : 'issue' ),
1556 checkout => $issue->get_from_storage
1559 ) if C4::Context->config("enable_plugins");
1565 =head2 GetLoanLength
1567 my $loanlength = &GetLoanLength($borrowertype,$itemtype,branchcode)
1569 Get loan length for an itemtype, a borrower type and a branch
1574 my ( $categorycode, $itemtype, $branchcode ) = @_;
1576 # Set search precedences
1579 categorycode => $categorycode,
1580 itemtype => $itemtype,
1581 branchcode => $branchcode,
1584 categorycode => $categorycode,
1586 branchcode => $branchcode,
1589 categorycode => undef,
1590 itemtype => $itemtype,
1591 branchcode => $branchcode,
1594 categorycode => undef,
1596 branchcode => $branchcode,
1599 categorycode => $categorycode,
1600 itemtype => $itemtype,
1601 branchcode => undef,
1604 categorycode => $categorycode,
1606 branchcode => undef,
1609 categorycode => undef,
1610 itemtype => $itemtype,
1611 branchcode => undef,
1614 categorycode => undef,
1616 branchcode => undef,
1620 # Initialize default values
1624 lengthunit => 'days',
1628 foreach my $rule_name (qw( issuelength renewalperiod lengthunit )) {
1629 foreach my $params (@params) {
1630 my $rule = Koha::CirculationRules->search(
1632 rule_name => $rule_name,
1638 $rules->{$rule_name} = $rule->rule_value;
1648 =head2 GetHardDueDate
1650 my ($hardduedate,$hardduedatecompare) = &GetHardDueDate($borrowertype,$itemtype,branchcode)
1652 Get the Hard Due Date and it's comparison for an itemtype, a borrower type and a branch
1656 sub GetHardDueDate {
1657 my ( $borrowertype, $itemtype, $branchcode ) = @_;
1659 my $rules = Koha::CirculationRules->get_effective_rules(
1661 categorycode => $borrowertype,
1662 itemtype => $itemtype,
1663 branchcode => $branchcode,
1664 rules => [ 'hardduedate', 'hardduedatecompare' ],
1668 if ( defined( $rules->{hardduedate} ) ) {
1669 if ( $rules->{hardduedate} ) {
1670 return ( dt_from_string( $rules->{hardduedate}, 'iso' ), $rules->{hardduedatecompare} );
1673 return ( undef, undef );
1678 =head2 GetBranchBorrowerCircRule
1680 my $branch_cat_rule = GetBranchBorrowerCircRule($branchcode, $categorycode);
1682 Retrieves circulation rule attributes that apply to the given
1683 branch and patron category, regardless of item type.
1684 The return value is a hashref containing the following key:
1686 patron_maxissueqty - maximum number of loans that a
1687 patron of the given category can have at the given
1688 branch. If the value is undef, no limit.
1690 patron_maxonsiteissueqty - maximum of on-site checkouts that a
1691 patron of the given category can have at the given
1692 branch. If the value is undef, no limit.
1694 This will check for different branch/category combinations in the following order:
1698 default branch and category
1700 If no rule has been found in the database, it will default to
1703 patron_maxissueqty - undef
1704 patron_maxonsiteissueqty - undef
1706 C<$branchcode> and C<$categorycode> should contain the
1707 literal branch code and patron category code, respectively - no
1712 sub GetBranchBorrowerCircRule {
1713 my ( $branchcode, $categorycode ) = @_;
1715 # Initialize default values
1717 patron_maxissueqty => undef,
1718 patron_maxonsiteissueqty => undef,
1722 foreach my $rule_name (qw( patron_maxissueqty patron_maxonsiteissueqty )) {
1723 my $rule = Koha::CirculationRules->get_effective_rule(
1725 categorycode => $categorycode,
1727 branchcode => $branchcode,
1728 rule_name => $rule_name,
1732 $rules->{$rule_name} = $rule->rule_value if defined $rule;
1738 =head2 GetBranchItemRule
1740 my $branch_item_rule = GetBranchItemRule($branchcode, $itemtype);
1742 Retrieves circulation rule attributes that apply to the given
1743 branch and item type, regardless of patron category.
1745 The return value is a hashref containing the following keys:
1747 holdallowed => Hold policy for this branch and itemtype. Possible values:
1748 0: No holds allowed.
1749 1: Holds allowed only by patrons that have the same homebranch as the item.
1750 2: Holds allowed from any patron.
1752 returnbranch => branch to which to return item. Possible values:
1753 noreturn: do not return, let item remain where checked in (floating collections)
1754 homebranch: return to item's home branch
1755 holdingbranch: return to issuer branch
1757 This searches branchitemrules in the following order:
1759 * Same branchcode and itemtype
1760 * Same branchcode, itemtype '*'
1761 * branchcode '*', same itemtype
1762 * branchcode and itemtype '*'
1764 Neither C<$branchcode> nor C<$itemtype> should be '*'.
1768 sub GetBranchItemRule {
1769 my ( $branchcode, $itemtype ) = @_;
1772 my $holdallowed_rule = Koha::CirculationRules->get_effective_rule(
1774 branchcode => $branchcode,
1775 itemtype => $itemtype,
1776 rule_name => 'holdallowed',
1779 my $hold_fulfillment_policy_rule = Koha::CirculationRules->get_effective_rule(
1781 branchcode => $branchcode,
1782 itemtype => $itemtype,
1783 rule_name => 'hold_fulfillment_policy',
1786 my $returnbranch_rule = Koha::CirculationRules->get_effective_rule(
1788 branchcode => $branchcode,
1789 itemtype => $itemtype,
1790 rule_name => 'returnbranch',
1794 # built-in default circulation rule
1796 $rules->{holdallowed} = defined $holdallowed_rule
1797 ? $holdallowed_rule->rule_value
1799 $rules->{hold_fulfillment_policy} = defined $hold_fulfillment_policy_rule
1800 ? $hold_fulfillment_policy_rule->rule_value
1802 $rules->{returnbranch} = defined $returnbranch_rule
1803 ? $returnbranch_rule->rule_value
1811 ($doreturn, $messages, $iteminformation, $borrower) =
1812 &AddReturn( $barcode, $branch [,$exemptfine] [,$returndate] );
1818 =item C<$barcode> is the bar code of the book being returned.
1820 =item C<$branch> is the code of the branch where the book is being returned.
1822 =item C<$exemptfine> indicates that overdue charges for the item will be
1825 =item C<$return_date> allows the default return date to be overridden
1826 by the given return date. Optional.
1830 C<&AddReturn> returns a list of four items:
1832 C<$doreturn> is true iff the return succeeded.
1834 C<$messages> is a reference-to-hash giving feedback on the operation.
1835 The keys of the hash are:
1841 No item with this barcode exists. The value is C<$barcode>.
1845 The book is not currently on loan. The value is C<$barcode>.
1849 This book has been withdrawn/cancelled. The value should be ignored.
1851 =item C<Wrongbranch>
1853 This book has was returned to the wrong branch. The value is a hashref
1854 so that C<$messages->{Wrongbranch}->{Wrongbranch}> and C<$messages->{Wrongbranch}->{Rightbranch}>
1855 contain the branchcode of the incorrect and correct return library, respectively.
1859 The item was reserved. The value is a reference-to-hash whose keys are
1860 fields from the reserves table of the Koha database, and
1861 C<biblioitemnumber>. It also has the key C<ResFound>, whose value is
1862 either C<Waiting>, C<Reserved>, or 0.
1864 =item C<WasReturned>
1866 Value 1 if return is successful.
1868 =item C<NeedsTransfer>
1870 If AutomaticItemReturn is disabled, return branch is given as value of NeedsTransfer.
1874 C<$iteminformation> is a reference-to-hash, giving information about the
1875 returned item from the issues table.
1877 C<$borrower> is a reference-to-hash, giving information about the
1878 patron who last borrowed the book.
1883 my ( $barcode, $branch, $exemptfine, $return_date ) = @_;
1885 if ($branch and not Koha::Libraries->find($branch)) {
1886 warn "AddReturn error: branch '$branch' not found. Reverting to " . C4::Context->userenv->{'branch'};
1889 $branch = C4::Context->userenv->{'branch'} unless $branch; # we trust userenv to be a safe fallback/default
1890 my $return_date_specified = !!$return_date;
1891 $return_date //= dt_from_string();
1895 my $validTransfert = 0;
1896 my $stat_type = 'return';
1898 # get information on item
1899 my $item = Koha::Items->find({ barcode => $barcode });
1901 return ( 0, { BadBarcode => $barcode } ); # no barcode means no item or borrower. bail out.
1904 my $itemnumber = $item->itemnumber;
1905 my $itemtype = $item->effective_itemtype;
1907 my $issue = $item->checkout;
1909 $patron = $issue->patron
1910 or die "Data inconsistency: barcode $barcode (itemnumber:$itemnumber) claims to be issued to non-existent borrowernumber '" . $issue->borrowernumber . "'\n"
1911 . Dumper($issue->unblessed) . "\n";
1913 $messages->{'NotIssued'} = $barcode;
1914 $item->onloan(undef)->store if defined $item->onloan;
1916 # even though item is not on loan, it may still be transferred; therefore, get current branch info
1918 # No issue, no borrowernumber. ONLY if $doreturn, *might* you have a $borrower later.
1919 # Record this as a local use, instead of a return, if the RecordLocalUseOnReturn is on
1920 if (C4::Context->preference("RecordLocalUseOnReturn")) {
1921 $messages->{'LocalUse'} = 1;
1922 $stat_type = 'localuse';
1926 # full item data, but no borrowernumber or checkout info (no issue)
1927 my $hbr = GetBranchItemRule($item->homebranch, $itemtype)->{'returnbranch'} || "homebranch";
1928 # get the proper branch to which to return the item
1929 my $returnbranch = $hbr ne 'noreturn' ? $item->$hbr : $branch;
1930 # if $hbr was "noreturn" or any other non-item table value, then it should 'float' (i.e. stay at this branch)
1931 my $transfer_trigger = $hbr eq 'homebranch' ? 'ReturnToHome' : $hbr eq 'holdingbranch' ? 'ReturnToHolding' : undef;
1933 my $borrowernumber = $patron ? $patron->borrowernumber : undef; # we don't know if we had a borrower or not
1934 my $patron_unblessed = $patron ? $patron->unblessed : {};
1936 my $update_loc_rules = get_yaml_pref_hash('UpdateItemLocationOnCheckin');
1937 map { $update_loc_rules->{$_} = $update_loc_rules->{$_}[0] } keys %$update_loc_rules; #We can only move to one location so we flatten the arrays
1938 if ($update_loc_rules) {
1939 if (defined $update_loc_rules->{_ALL_}) {
1940 if ($update_loc_rules->{_ALL_} eq '_PERM_') { $update_loc_rules->{_ALL_} = $item->permanent_location; }
1941 if ($update_loc_rules->{_ALL_} eq '_BLANK_') { $update_loc_rules->{_ALL_} = ''; }
1942 if ( $item->location ne $update_loc_rules->{_ALL_}) {
1943 $messages->{'ItemLocationUpdated'} = { from => $item->location, to => $update_loc_rules->{_ALL_} };
1944 $item->location($update_loc_rules->{_ALL_})->store;
1948 foreach my $key ( keys %$update_loc_rules ) {
1949 if ( $update_loc_rules->{$key} eq '_PERM_' ) { $update_loc_rules->{$key} = $item->permanent_location; }
1950 if ( $update_loc_rules->{$key} eq '_BLANK_') { $update_loc_rules->{$key} = '' ;}
1951 if ( ($item->location eq $key && $item->location ne $update_loc_rules->{$key}) || ($key eq '_BLANK_' && $item->location eq '' && $update_loc_rules->{$key} ne '') ) {
1952 $messages->{'ItemLocationUpdated'} = { from => $item->location, to => $update_loc_rules->{$key} };
1953 $item->location($update_loc_rules->{$key})->store;
1960 my $yaml = C4::Context->preference('UpdateNotForLoanStatusOnCheckin');
1962 $yaml = "$yaml\n\n"; # YAML is anal on ending \n. Surplus does not hurt
1964 eval { $rules = YAML::Load($yaml); };
1966 warn "Unable to parse UpdateNotForLoanStatusOnCheckin syspref : $@";
1969 foreach my $key ( keys %$rules ) {
1970 if ( $item->notforloan eq $key ) {
1971 $messages->{'NotForLoanStatusUpdated'} = { from => $item->notforloan, to => $rules->{$key} };
1972 $item->notforloan($rules->{$key})->store({ log_action => 0 });
1979 # check if the return is allowed at this branch
1980 my ($returnallowed, $message) = CanBookBeReturned($item->unblessed, $branch);
1981 unless ($returnallowed){
1982 $messages->{'Wrongbranch'} = {
1983 Wrongbranch => $branch,
1984 Rightbranch => $message
1987 return ( $doreturn, $messages, $issue, $patron_unblessed);
1990 if ( $item->withdrawn ) { # book has been cancelled
1991 $messages->{'withdrawn'} = 1;
1992 $doreturn = 0 if C4::Context->preference("BlockReturnOfWithdrawnItems");
1995 if ( $item->itemlost and C4::Context->preference("BlockReturnOfLostItems") ) {
1999 # case of a return of document (deal with issues and holdingbranch)
2001 die "The item is not issed and cannot be returned" unless $issue; # Just in case...
2002 $patron or warn "AddReturn without current borrower";
2006 MarkIssueReturned( $borrowernumber, $item->itemnumber, $return_date, $patron->privacy );
2011 C4::Context->preference('CalculateFinesOnReturn')
2012 || ( $return_date_specified && C4::Context->preference('CalculateFinesOnBackdate') )
2017 _CalculateAndUpdateFine( { issue => $issue, item => $item->unblessed, borrower => $patron_unblessed, return_date => $return_date } );
2020 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 );
2022 return ( 0, { WasReturned => 0, DataCorrupted => 1 }, $issue, $patron_unblessed );
2025 # FIXME is the "= 1" right? This could be the borrower hash.
2026 $messages->{'WasReturned'} = 1;
2030 $item->onloan(undef)->store({ log_action => 0 });
2033 # the holdingbranch is updated if the document is returned to another location.
2034 # this is always done regardless of whether the item was on loan or not
2035 my $item_holding_branch = $item->holdingbranch;
2036 if ($item->holdingbranch ne $branch) {
2037 $item->holdingbranch($branch)->store;
2040 my $leave_item_lost = C4::Context->preference("BlockReturnOfLostItems") ? 1 : 0;
2041 ModDateLastSeen( $item->itemnumber, $leave_item_lost );
2043 # check if we have a transfer for this document
2044 my ($datesent,$frombranch,$tobranch) = GetTransfers( $item->itemnumber );
2046 # if we have a transfer to do, we update the line of transfers with the datearrived
2047 my $is_in_rotating_collection = C4::RotatingCollections::isItemInAnyCollection( $item->itemnumber );
2049 if ( $tobranch eq $branch ) {
2050 my $sth = C4::Context->dbh->prepare(
2051 "UPDATE branchtransfers SET datearrived = now() WHERE itemnumber= ? AND datearrived IS NULL"
2053 $sth->execute( $item->itemnumber );
2055 $messages->{'WrongTransfer'} = $tobranch;
2056 $messages->{'WrongTransferItem'} = $item->itemnumber;
2058 $validTransfert = 1;
2061 # fix up the accounts.....
2062 if ( $item->itemlost ) {
2063 $messages->{'WasLost'} = 1;
2064 unless ( C4::Context->preference("BlockReturnOfLostItems") ) {
2066 my $no_refund_after_days = C4::Context->preference('NoRefundOnLostReturnedItemsAge');
2067 if ($no_refund_after_days) {
2068 my $today = dt_from_string();
2069 my $lost_age_in_days =
2070 dt_from_string( $item->itemlost_on )
2071 ->delta_days($today)
2074 $refund = 0 unless ( $lost_age_in_days < $no_refund_after_days );
2079 Koha::RefundLostItemFeeRules->should_refund(
2081 current_branch => C4::Context->userenv->{branch},
2082 item_home_branch => $item->homebranch,
2083 item_holding_branch => $item_holding_branch
2088 _FixAccountForLostAndFound( $item->itemnumber,
2089 $borrowernumber, $barcode );
2090 $messages->{'LostItemFeeRefunded'} = 1;
2095 # fix up the overdues in accounts...
2096 if ($borrowernumber) {
2097 my $fix = _FixOverduesOnReturn( $borrowernumber, $item->itemnumber, $exemptfine, 'RETURNED' );
2098 defined($fix) or warn "_FixOverduesOnReturn($borrowernumber, ".$item->itemnumber."...) failed!"; # zero is OK, check defined
2100 if ( $issue and $issue->is_overdue($return_date) ) {
2102 my ($debardate,$reminder) = _debar_user_on_return( $patron_unblessed, $item->unblessed, dt_from_string($issue->date_due), $return_date );
2104 $messages->{'PrevDebarred'} = $debardate;
2106 $messages->{'Debarred'} = $debardate if $debardate;
2108 # there's no overdue on the item but borrower had been previously debarred
2109 } elsif ( $issue->date_due and $patron->debarred ) {
2110 if ( $patron->debarred eq "9999-12-31") {
2111 $messages->{'ForeverDebarred'} = $patron->debarred;
2113 my $borrower_debar_dt = dt_from_string( $patron->debarred );
2114 $borrower_debar_dt->truncate(to => 'day');
2115 my $today_dt = $return_date->clone()->truncate(to => 'day');
2116 if ( DateTime->compare( $borrower_debar_dt, $today_dt ) != -1 ) {
2117 $messages->{'PrevDebarred'} = $patron->debarred;
2123 # find reserves.....
2124 # launch the Checkreserves routine to find any holds
2125 my ($resfound, $resrec);
2126 my $lookahead= C4::Context->preference('ConfirmFutureHolds'); #number of days to look for future holds
2127 ($resfound, $resrec, undef) = C4::Reserves::CheckReserves( $item->itemnumber, undef, $lookahead ) unless ( $item->withdrawn );
2128 # 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)
2129 if ( $resfound eq "Waiting" and $branch ne $resrec->{branchcode} ) {
2130 my $hold = C4::Reserves::RevertWaitingStatus( { itemnumber => $item->itemnumber } );
2131 $resfound = 'Reserved';
2132 $resrec = $hold->unblessed;
2135 $resrec->{'ResFound'} = $resfound;
2136 $messages->{'ResFound'} = $resrec;
2139 # Record the fact that this book was returned.
2143 itemnumber => $itemnumber,
2144 itemtype => $itemtype,
2145 location => $item->location,
2146 borrowernumber => $borrowernumber,
2147 ccode => $item->ccode,
2150 # Send a check-in slip. # NOTE: borrower may be undef. Do not try to send messages then.
2152 my $circulation_alert = 'C4::ItemCirculationAlertPreference';
2154 branchcode => $branch,
2155 categorycode => $patron->categorycode,
2156 item_type => $itemtype,
2157 notification => 'CHECKIN',
2159 if ($doreturn && $circulation_alert->is_enabled_for(\%conditions)) {
2160 SendCirculationAlert({
2162 item => $item->unblessed,
2163 borrower => $patron->unblessed,
2168 logaction("CIRCULATION", "RETURN", $borrowernumber, $item->itemnumber)
2169 if C4::Context->preference("ReturnLog");
2172 # Check if this item belongs to a biblio record that is attached to an
2173 # ILL request, if it is we need to update the ILL request's status
2174 if (C4::Context->preference('CirculateILL')) {
2175 my $request = Koha::Illrequests->find(
2176 { biblio_id => $item->biblio->biblionumber }
2178 $request->status('RET') if $request;
2181 # Transfer to returnbranch if Automatic transfer set or append message NeedsTransfer
2182 if (!$is_in_rotating_collection && ($doreturn or $messages->{'NotIssued'}) and !$resfound and ($branch ne $returnbranch) and not $messages->{'WrongTransfer'}){
2183 my $BranchTransferLimitsType = C4::Context->preference("BranchTransferLimitsType") eq 'itemtype' ? 'effective_itemtype' : 'ccode';
2184 if (C4::Context->preference("AutomaticItemReturn" ) or
2185 (C4::Context->preference("UseBranchTransferLimits") and
2186 ! IsBranchTransferAllowed($branch, $returnbranch, $item->$BranchTransferLimitsType )
2188 $debug and warn sprintf "about to call ModItemTransfer(%s, %s, %s, %s)", $item->itemnumber,$branch, $returnbranch, $transfer_trigger;
2189 $debug and warn "item: " . Dumper($item->unblessed);
2190 ModItemTransfer($item->itemnumber, $branch, $returnbranch, $transfer_trigger);
2191 $messages->{'WasTransfered'} = 1;
2193 $messages->{'NeedsTransfer'} = $returnbranch;
2194 $messages->{'TransferTrigger'} = $transfer_trigger;
2198 if ( C4::Context->preference('ClaimReturnedLostValue') ) {
2199 my $claims = Koha::Checkouts::ReturnClaims->search(
2201 itemnumber => $item->id,
2202 resolution => undef,
2206 if ( $claims->count ) {
2207 $messages->{ReturnClaims} = $claims;
2211 my $checkin = Koha::Old::Checkouts->find($issue->id);
2213 _after_circ_actions(
2215 action => 'checkin',
2220 ) if C4::Context->config("enable_plugins");
2222 return ( $doreturn, $messages, $issue, ( $patron ? $patron->unblessed : {} ));
2225 =head2 MarkIssueReturned
2227 MarkIssueReturned($borrowernumber, $itemnumber, $returndate, $privacy);
2229 Unconditionally marks an issue as being returned by
2230 moving the C<issues> row to C<old_issues> and
2231 setting C<returndate> to the current date.
2233 if C<$returndate> is specified (in iso format), it is used as the date
2236 C<$privacy> contains the privacy parameter. If the patron has set privacy to 2,
2237 the old_issue is immediately anonymised
2239 Ideally, this function would be internal to C<C4::Circulation>,
2240 not exported, but it is currently used in misc/cronjobs/longoverdue.pl
2241 and offline_circ/process_koc.pl.
2245 sub MarkIssueReturned {
2246 my ( $borrowernumber, $itemnumber, $returndate, $privacy ) = @_;
2248 # Retrieve the issue
2249 my $issue = Koha::Checkouts->find( { itemnumber => $itemnumber } ) or return;
2251 return unless $issue->borrowernumber == $borrowernumber; # If the item is checked out to another patron we do not return it
2253 my $issue_id = $issue->issue_id;
2255 my $anonymouspatron;
2256 if ( $privacy && $privacy == 2 ) {
2257 # The default of 0 will not work due to foreign key constraints
2258 # The anonymisation will fail if AnonymousPatron is not a valid entry
2259 # We need to check if the anonymous patron exist, Koha will fail loudly if it does not
2260 # Note that a warning should appear on the about page (System information tab).
2261 $anonymouspatron = C4::Context->preference('AnonymousPatron');
2262 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."
2263 unless Koha::Patrons->find( $anonymouspatron );
2266 my $schema = Koha::Database->schema;
2268 # FIXME Improve the return value and handle it from callers
2269 $schema->txn_do(sub {
2271 my $patron = Koha::Patrons->find( $borrowernumber );
2273 # Update the returndate value
2274 if ( $returndate ) {
2275 $issue->returndate( $returndate )->store->discard_changes; # update and refetch
2278 $issue->returndate( \'NOW()' )->store->discard_changes; # update and refetch
2281 # Create the old_issues entry
2282 my $old_checkout = Koha::Old::Checkout->new($issue->unblessed)->store;
2284 # anonymise patron checkout immediately if $privacy set to 2 and AnonymousPatron is set to a valid borrowernumber
2285 if ( $privacy && $privacy == 2) {
2286 $old_checkout->borrowernumber($anonymouspatron)->store;
2289 # And finally delete the issue
2292 $issue->item->onloan(undef)->store({ log_action => 0 });
2294 if ( C4::Context->preference('StoreLastBorrower') ) {
2295 my $item = Koha::Items->find( $itemnumber );
2296 $item->last_returned_by( $patron );
2299 # Remove any OVERDUES related debarment if the borrower has no overdues
2300 if ( C4::Context->preference('AutoRemoveOverduesRestrictions')
2301 && $patron->debarred
2302 && !$patron->has_overdues
2303 && @{ GetDebarments({ borrowernumber => $borrowernumber, type => 'OVERDUES' }) }
2305 DelUniqueDebarment({ borrowernumber => $borrowernumber, type => 'OVERDUES' });
2313 =head2 _debar_user_on_return
2315 _debar_user_on_return($borrower, $item, $datedue, $returndate);
2317 C<$borrower> borrower hashref
2319 C<$item> item hashref
2321 C<$datedue> date due DateTime object
2323 C<$returndate> DateTime object representing the return time
2325 Internal function, called only by AddReturn that calculates and updates
2326 the user fine days, and debars them if necessary.
2328 Should only be called for overdue returns
2330 Calculation of the debarment date has been moved to a separate subroutine _calculate_new_debar_dt
2335 sub _calculate_new_debar_dt {
2336 my ( $borrower, $item, $dt_due, $return_date ) = @_;
2338 my $branchcode = _GetCircControlBranch( $item, $borrower );
2339 my $circcontrol = C4::Context->preference('CircControl');
2340 my $issuing_rule = Koha::CirculationRules->get_effective_rules(
2341 { categorycode => $borrower->{categorycode},
2342 itemtype => $item->{itype},
2343 branchcode => $branchcode,
2348 'maxsuspensiondays',
2349 'suspension_chargeperiod',
2353 my $finedays = $issuing_rule ? $issuing_rule->{finedays} : undef;
2354 my $unit = $issuing_rule ? $issuing_rule->{lengthunit} : undef;
2355 my $chargeable_units = C4::Overdues::get_chargeable_units($unit, $dt_due, $return_date, $branchcode);
2357 return unless $finedays;
2359 # finedays is in days, so hourly loans must multiply by 24
2360 # thus 1 hour late equals 1 day suspension * finedays rate
2361 $finedays = $finedays * 24 if ( $unit eq 'hours' );
2363 # grace period is measured in the same units as the loan
2365 DateTime::Duration->new( $unit => $issuing_rule->{firstremind} );
2367 my $deltadays = DateTime::Duration->new(
2368 days => $chargeable_units
2371 if ( $deltadays->subtract($grace)->is_positive() ) {
2372 my $suspension_days = $deltadays * $finedays;
2374 if ( defined $issuing_rule->{suspension_chargeperiod} && $issuing_rule->{suspension_chargeperiod} > 1 ) {
2375 # No need to / 1 and do not consider / 0
2376 $suspension_days = DateTime::Duration->new(
2377 days => floor( $suspension_days->in_units('days') / $issuing_rule->{suspension_chargeperiod} )
2381 # If the max suspension days is < than the suspension days
2382 # the suspension days is limited to this maximum period.
2383 my $max_sd = $issuing_rule->{maxsuspensiondays};
2384 if ( defined $max_sd && $max_sd ne '' ) {
2385 $max_sd = DateTime::Duration->new( days => $max_sd );
2386 $suspension_days = $max_sd
2387 if DateTime::Duration->compare( $max_sd, $suspension_days ) < 0;
2390 my ( $has_been_extended );
2391 if ( C4::Context->preference('CumulativeRestrictionPeriods') and $borrower->{debarred} ) {
2392 my $debarment = @{ GetDebarments( { borrowernumber => $borrower->{borrowernumber}, type => 'SUSPENSION' } ) }[0];
2394 $return_date = dt_from_string( $debarment->{expiration}, 'sql' );
2395 $has_been_extended = 1;
2400 # Use the calendar or not to calculate the debarment date
2401 if ( C4::Context->preference('SuspensionsCalendar') eq 'noSuspensionsWhenClosed' ) {
2402 my $calendar = Koha::Calendar->new(
2403 branchcode => $branchcode,
2404 days_mode => 'Calendar'
2406 $new_debar_dt = $calendar->addDate( $return_date, $suspension_days );
2409 $new_debar_dt = $return_date->clone()->add_duration($suspension_days);
2411 return $new_debar_dt;
2416 sub _debar_user_on_return {
2417 my ( $borrower, $item, $dt_due, $return_date ) = @_;
2419 $return_date //= dt_from_string();
2421 my $new_debar_dt = _calculate_new_debar_dt ($borrower, $item, $dt_due, $return_date);
2423 return unless $new_debar_dt;
2425 Koha::Patron::Debarments::AddUniqueDebarment({
2426 borrowernumber => $borrower->{borrowernumber},
2427 expiration => $new_debar_dt->ymd(),
2428 type => 'SUSPENSION',
2430 # if borrower was already debarred but does not get an extra debarment
2431 my $patron = Koha::Patrons->find( $borrower->{borrowernumber} );
2432 my ($new_debarment_str, $is_a_reminder);
2433 if ( $borrower->{debarred} && $borrower->{debarred} eq $patron->is_debarred ) {
2435 $new_debarment_str = $borrower->{debarred};
2437 $new_debarment_str = $new_debar_dt->ymd();
2439 # FIXME Should return a DateTime object
2440 return $new_debarment_str, $is_a_reminder;
2443 =head2 _FixOverduesOnReturn
2445 &_FixOverduesOnReturn($borrowernumber, $itemnumber, $exemptfine, $status);
2447 C<$borrowernumber> borrowernumber
2449 C<$itemnumber> itemnumber
2451 C<$exemptfine> BOOL -- remove overdue charge associated with this issue.
2453 C<$status> ENUM -- reason for fix [ RETURNED, RENEWED, LOST, FORGIVEN ]
2459 sub _FixOverduesOnReturn {
2460 my ( $borrowernumber, $item, $exemptfine, $status ) = @_;
2461 unless( $borrowernumber ) {
2462 warn "_FixOverduesOnReturn() not supplied valid borrowernumber";
2466 warn "_FixOverduesOnReturn() not supplied valid itemnumber";
2470 warn "_FixOverduesOnReturn() not supplied valid status";
2474 my $schema = Koha::Database->schema;
2476 my $result = $schema->txn_do(
2478 # check for overdue fine
2479 my $accountlines = Koha::Account::Lines->search(
2481 borrowernumber => $borrowernumber,
2482 itemnumber => $item,
2483 debit_type_code => 'OVERDUE',
2484 status => 'UNRETURNED'
2487 return 0 unless $accountlines->count; # no warning, there's just nothing to fix
2489 my $accountline = $accountlines->next;
2490 my $payments = $accountline->credits;
2492 my $amountoutstanding = $accountline->amountoutstanding;
2493 if ( $accountline->amount == 0 && $payments->count == 0 ) {
2494 $accountline->delete;
2495 } elsif ($exemptfine && ($amountoutstanding != 0)) {
2496 my $account = Koha::Account->new({patron_id => $borrowernumber});
2497 my $credit = $account->add_credit(
2499 amount => $amountoutstanding,
2500 user_id => C4::Context->userenv ? C4::Context->userenv->{'number'} : undef,
2501 library_id => C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef,
2502 interface => C4::Context->interface,
2508 $credit->apply({ debits => [ $accountline ], offset_type => 'Forgiven' });
2510 if (C4::Context->preference("FinesLog")) {
2511 &logaction("FINES", 'MODIFY',$borrowernumber,"Overdue forgiven: item $item");
2514 $accountline->status('FORGIVEN');
2515 $accountline->store();
2517 $accountline->status($status);
2518 $accountline->store();
2527 =head2 _FixAccountForLostAndFound
2529 &_FixAccountForLostAndFound($itemnumber, [$borrowernumber, $barcode]);
2531 Finds the most recent lost item charge for this item and refunds the borrower
2532 appropriatly, taking into account any payments or writeoffs already applied
2535 Internal function, not exported, called only by AddReturn.
2539 sub _FixAccountForLostAndFound {
2540 my $itemnumber = shift or return;
2541 my $borrowernumber = @_ ? shift : undef;
2542 my $item_id = @_ ? shift : $itemnumber; # Send the barcode if you want that logged in the description
2546 # check for charge made for lost book
2547 my $accountlines = Koha::Account::Lines->search(
2549 itemnumber => $itemnumber,
2550 debit_type_code => 'LOST',
2551 status => [ undef, { '<>' => 'FOUND' } ]
2554 order_by => { -desc => [ 'date', 'accountlines_id' ] }
2558 return unless $accountlines->count > 0;
2559 my $accountline = $accountlines->next;
2560 my $total_to_refund = 0;
2562 return unless $accountline->borrowernumber;
2563 my $patron = Koha::Patrons->find( $accountline->borrowernumber );
2564 return unless $patron; # Patron has been deleted, nobody to credit the return to
2566 my $account = $patron->account;
2569 if ( $accountline->amount > $accountline->amountoutstanding ) {
2570 # some amount has been cancelled. collect the offsets that are not writeoffs
2571 # this works because the only way to subtract from this kind of a debt is
2572 # using the UI buttons 'Pay' and 'Write off'
2573 my $credits_offsets = Koha::Account::Offsets->search({
2574 debit_id => $accountline->id,
2575 credit_id => { '!=' => undef }, # it is not the debit itself
2576 type => { '!=' => 'Writeoff' },
2577 amount => { '<' => 0 } # credits are negative on the DB
2580 $total_to_refund = ( $credits_offsets->count > 0 )
2581 ? $credits_offsets->total * -1 # credits are negative on the DB
2585 my $credit_total = $accountline->amountoutstanding + $total_to_refund;
2587 if ( $credit_total > 0 ) {
2588 my $branchcode = C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
2589 $credit = $account->add_credit(
2591 amount => $credit_total,
2592 description => 'Item found ' . $item_id,
2593 type => 'LOST_FOUND',
2594 interface => C4::Context->interface,
2595 library_id => $branchcode,
2596 item_id => $itemnumber
2600 $credit->apply( { debits => [ $accountline ] } );
2603 # Update the account status
2604 $accountline->discard_changes->status('FOUND');
2605 $accountline->store;
2607 $accountline->item->paidfor('')->store({ log_action => 0 });
2609 if ( defined $account and C4::Context->preference('AccountAutoReconcile') ) {
2610 $account->reconcile_balance;
2613 return ($credit) ? $credit->id : undef;
2616 =head2 _GetCircControlBranch
2618 my $circ_control_branch = _GetCircControlBranch($iteminfos, $borrower);
2622 Return the library code to be used to determine which circulation
2623 policy applies to a transaction. Looks up the CircControl and
2624 HomeOrHoldingBranch system preferences.
2626 C<$iteminfos> is a hashref to iteminfo. Only {homebranch or holdingbranch} is used.
2628 C<$borrower> is a hashref to borrower. Only {branchcode} is used.
2632 sub _GetCircControlBranch {
2633 my ($item, $borrower) = @_;
2634 my $circcontrol = C4::Context->preference('CircControl');
2637 if ($circcontrol eq 'PickupLibrary' and (C4::Context->userenv and C4::Context->userenv->{'branch'}) ) {
2638 $branch= C4::Context->userenv->{'branch'};
2639 } elsif ($circcontrol eq 'PatronLibrary') {
2640 $branch=$borrower->{branchcode};
2642 my $branchfield = C4::Context->preference('HomeOrHoldingBranch') || 'homebranch';
2643 $branch = $item->{$branchfield};
2644 # default to item home branch if holdingbranch is used
2645 # and is not defined
2646 if (!defined($branch) && $branchfield eq 'holdingbranch') {
2647 $branch = $item->{homebranch};
2655 $issue = GetOpenIssue( $itemnumber );
2657 Returns the row from the issues table if the item is currently issued, undef if the item is not currently issued
2659 C<$itemnumber> is the item's itemnumber
2666 my ( $itemnumber ) = @_;
2667 return unless $itemnumber;
2668 my $dbh = C4::Context->dbh;
2669 my $sth = $dbh->prepare( "SELECT * FROM issues WHERE itemnumber = ? AND returndate IS NULL" );
2670 $sth->execute( $itemnumber );
2671 return $sth->fetchrow_hashref();
2675 =head2 GetBiblioIssues
2677 $issues = GetBiblioIssues($biblionumber);
2679 this function get all issues from a biblionumber.
2682 C<$issues> is a reference to array which each value is ref-to-hash. This ref-to-hash contains all column from
2683 tables issues and the firstname,surname & cardnumber from borrowers.
2687 sub GetBiblioIssues {
2688 my $biblionumber = shift;
2689 return unless $biblionumber;
2690 my $dbh = C4::Context->dbh;
2692 SELECT issues.*,items.barcode,biblio.biblionumber,biblio.title, biblio.author,borrowers.cardnumber,borrowers.surname,borrowers.firstname
2694 LEFT JOIN borrowers ON borrowers.borrowernumber = issues.borrowernumber
2695 LEFT JOIN items ON issues.itemnumber = items.itemnumber
2696 LEFT JOIN biblioitems ON items.itemnumber = biblioitems.biblioitemnumber
2697 LEFT JOIN biblio ON biblio.biblionumber = items.biblionumber
2698 WHERE biblio.biblionumber = ?
2700 SELECT old_issues.*,items.barcode,biblio.biblionumber,biblio.title, biblio.author,borrowers.cardnumber,borrowers.surname,borrowers.firstname
2702 LEFT JOIN borrowers ON borrowers.borrowernumber = old_issues.borrowernumber
2703 LEFT JOIN items ON old_issues.itemnumber = items.itemnumber
2704 LEFT JOIN biblioitems ON items.itemnumber = biblioitems.biblioitemnumber
2705 LEFT JOIN biblio ON biblio.biblionumber = items.biblionumber
2706 WHERE biblio.biblionumber = ?
2709 my $sth = $dbh->prepare($query);
2710 $sth->execute($biblionumber, $biblionumber);
2713 while ( my $data = $sth->fetchrow_hashref ) {
2714 push @issues, $data;
2719 =head2 GetUpcomingDueIssues
2721 my $upcoming_dues = GetUpcomingDueIssues( { days_in_advance => 4 } );
2725 sub GetUpcomingDueIssues {
2728 $params->{'days_in_advance'} = 7 unless exists $params->{'days_in_advance'};
2729 my $dbh = C4::Context->dbh;
2731 my $statement = <<END_SQL;
2734 SELECT issues.*, items.itype as itemtype, items.homebranch, TO_DAYS( date_due )-TO_DAYS( NOW() ) as days_until_due, branches.branchemail
2736 LEFT JOIN items USING (itemnumber)
2737 LEFT OUTER JOIN branches USING (branchcode)
2738 WHERE returndate is NULL
2740 WHERE days_until_due >= 0 AND days_until_due <= ?
2743 my @bind_parameters = ( $params->{'days_in_advance'} );
2745 my $sth = $dbh->prepare( $statement );
2746 $sth->execute( @bind_parameters );
2747 my $upcoming_dues = $sth->fetchall_arrayref({});
2749 return $upcoming_dues;
2752 =head2 CanBookBeRenewed
2754 ($ok,$error) = &CanBookBeRenewed($borrowernumber, $itemnumber[, $override_limit]);
2756 Find out whether a borrowed item may be renewed.
2758 C<$borrowernumber> is the borrower number of the patron who currently
2759 has the item on loan.
2761 C<$itemnumber> is the number of the item to renew.
2763 C<$override_limit>, if supplied with a true value, causes
2764 the limit on the number of times that the loan can be renewed
2765 (as controlled by the item type) to be ignored. Overriding also allows
2766 to renew sooner than "No renewal before" and to manually renew loans
2767 that are automatically renewed.
2769 C<$CanBookBeRenewed> returns a true value if the item may be renewed. The
2770 item must currently be on loan to the specified borrower; renewals
2771 must be allowed for the item's type; and the borrower must not have
2772 already renewed the loan. $error will contain the reason the renewal can not proceed
2776 sub CanBookBeRenewed {
2777 my ( $borrowernumber, $itemnumber, $override_limit ) = @_;
2779 my $dbh = C4::Context->dbh;
2783 my $item = Koha::Items->find($itemnumber) or return ( 0, 'no_item' );
2784 my $issue = $item->checkout or return ( 0, 'no_checkout' );
2785 return ( 0, 'onsite_checkout' ) if $issue->onsite_checkout;
2786 return ( 0, 'item_denied_renewal') if _item_denied_renewal({ item => $item });
2788 my $patron = $issue->patron or return;
2790 # override_limit will override anything else except on_reserve
2791 unless ( $override_limit ){
2792 my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
2793 my $issuing_rule = Koha::CirculationRules->get_effective_rules(
2795 categorycode => $patron->categorycode,
2796 itemtype => $item->effective_itemtype,
2797 branchcode => $branchcode,
2800 'no_auto_renewal_after',
2801 'no_auto_renewal_after_hard_limit',
2808 return ( 0, "too_many" )
2809 if not $issuing_rule->{renewalsallowed} or $issuing_rule->{renewalsallowed} <= $issue->renewals;
2811 my $overduesblockrenewing = C4::Context->preference('OverduesBlockRenewing');
2812 my $restrictionblockrenewing = C4::Context->preference('RestrictionBlockRenewing');
2813 $patron = Koha::Patrons->find($borrowernumber); # FIXME Is this really useful?
2814 my $restricted = $patron->is_debarred;
2815 my $hasoverdues = $patron->has_overdues;
2817 if ( $restricted and $restrictionblockrenewing ) {
2818 return ( 0, 'restriction');
2819 } elsif ( ($hasoverdues and $overduesblockrenewing eq 'block') || ($issue->is_overdue and $overduesblockrenewing eq 'blockitem') ) {
2820 return ( 0, 'overdue');
2823 if ( $issue->auto_renew && $patron->autorenew_checkouts ) {
2825 if ( $patron->category->effective_BlockExpiredPatronOpacActions and $patron->is_expired ) {
2826 return ( 0, 'auto_account_expired' );
2829 if ( defined $issuing_rule->{no_auto_renewal_after}
2830 and $issuing_rule->{no_auto_renewal_after} ne "" ) {
2831 # Get issue_date and add no_auto_renewal_after
2832 # If this is greater than today, it's too late for renewal.
2833 my $maximum_renewal_date = dt_from_string($issue->issuedate, 'sql');
2834 $maximum_renewal_date->add(
2835 $issuing_rule->{lengthunit} => $issuing_rule->{no_auto_renewal_after}
2837 my $now = dt_from_string;
2838 if ( $now >= $maximum_renewal_date ) {
2839 return ( 0, "auto_too_late" );
2842 if ( defined $issuing_rule->{no_auto_renewal_after_hard_limit}
2843 and $issuing_rule->{no_auto_renewal_after_hard_limit} ne "" ) {
2844 # If no_auto_renewal_after_hard_limit is >= today, it's also too late for renewal
2845 if ( dt_from_string >= dt_from_string( $issuing_rule->{no_auto_renewal_after_hard_limit} ) ) {
2846 return ( 0, "auto_too_late" );
2850 if ( C4::Context->preference('OPACFineNoRenewalsBlockAutoRenew') ) {
2851 my $fine_no_renewals = C4::Context->preference("OPACFineNoRenewals");
2852 my $amountoutstanding =
2853 C4::Context->preference("OPACFineNoRenewalsIncludeCredit")
2854 ? $patron->account->balance
2855 : $patron->account->outstanding_debits->total_outstanding;
2856 if ( $amountoutstanding and $amountoutstanding > $fine_no_renewals ) {
2857 return ( 0, "auto_too_much_oweing" );
2862 if ( defined $issuing_rule->{norenewalbefore}
2863 and $issuing_rule->{norenewalbefore} ne "" )
2866 # Calculate soonest renewal by subtracting 'No renewal before' from due date
2867 my $soonestrenewal = dt_from_string( $issue->date_due, 'sql' )->subtract(
2868 $issuing_rule->{lengthunit} => $issuing_rule->{norenewalbefore} );
2870 # Depending on syspref reset the exact time, only check the date
2871 if ( C4::Context->preference('NoRenewalBeforePrecision') eq 'date'
2872 and $issuing_rule->{lengthunit} eq 'days' )
2874 $soonestrenewal->truncate( to => 'day' );
2877 if ( $soonestrenewal > dt_from_string() )
2879 return ( 0, "auto_too_soon" ) if $issue->auto_renew && $patron->autorenew_checkouts;
2880 return ( 0, "too_soon" );
2882 elsif ( $issue->auto_renew && $patron->autorenew_checkouts ) {
2887 # Fallback for automatic renewals:
2888 # If norenewalbefore is undef, don't renew before due date.
2889 if ( $issue->auto_renew && !$auto_renew && $patron->autorenew_checkouts ) {
2890 my $now = dt_from_string;
2891 if ( $now >= dt_from_string( $issue->date_due, 'sql' ) ){
2894 return ( 0, "auto_too_soon" );
2899 my ( $resfound, $resrec, undef ) = C4::Reserves::CheckReserves($itemnumber);
2901 # This item can fill one or more unfilled reserve, can those unfilled reserves
2902 # all be filled by other available items?
2904 && C4::Context->preference('AllowRenewalIfOtherItemsAvailable') )
2906 my $schema = Koha::Database->new()->schema();
2908 my $item_holds = $schema->resultset('Reserve')->search( { itemnumber => $itemnumber, found => undef } )->count();
2910 # There is an item level hold on this item, no other item can fill the hold
2915 # Get all other items that could possibly fill reserves
2916 my @itemnumbers = $schema->resultset('Item')->search(
2918 biblionumber => $resrec->{biblionumber},
2921 -not => { itemnumber => $itemnumber }
2923 { columns => 'itemnumber' }
2924 )->get_column('itemnumber')->all();
2926 # Get all other reserves that could have been filled by this item
2927 my @borrowernumbers;
2929 my ( $reserve_found, $reserve, undef ) =
2930 C4::Reserves::CheckReserves( $itemnumber, undef, undef, \@borrowernumbers );
2932 if ($reserve_found) {
2933 push( @borrowernumbers, $reserve->{borrowernumber} );
2940 # If the count of the union of the lists of reservable items for each borrower
2941 # is equal or greater than the number of borrowers, we know that all reserves
2942 # can be filled with available items. We can get the union of the sets simply
2943 # by pushing all the elements onto an array and removing the duplicates.
2946 ITEM: foreach my $itemnumber (@itemnumbers) {
2947 my $item = Koha::Items->find( $itemnumber );
2948 next if IsItemOnHoldAndFound( $itemnumber );
2949 for my $borrowernumber (@borrowernumbers) {
2950 my $patron = $patrons{$borrowernumber} //= Koha::Patrons->find( $borrowernumber );
2951 next unless IsAvailableForItemLevelRequest($item, $patron);
2952 next unless CanItemBeReserved($borrowernumber,$itemnumber);
2954 push @reservable, $itemnumber;
2955 if (@reservable >= @borrowernumbers) {
2964 return ( 0, "on_reserve" ) if $resfound; # '' when no hold was found
2965 return ( 0, "auto_renew" ) if $auto_renew && !$override_limit; # 0 if auto-renewal should not succeed
2967 return ( 1, undef );
2972 &AddRenewal($borrowernumber, $itemnumber, $branch, [$datedue], [$lastreneweddate]);
2976 C<$borrowernumber> is the borrower number of the patron who currently
2979 C<$itemnumber> is the number of the item to renew.
2981 C<$branch> is the library where the renewal took place (if any).
2982 The library that controls the circ policies for the renewal is retrieved from the issues record.
2984 C<$datedue> can be a DateTime object used to set the due date.
2986 C<$lastreneweddate> is an optional ISO-formatted date used to set issues.lastreneweddate. If
2987 this parameter is not supplied, lastreneweddate is set to the current date.
2989 C<$skipfinecalc> is an optional boolean. There may be circumstances where, even if the
2990 CalculateFinesOnReturn syspref is enabled, we don't want to calculate fines upon renew,
2991 for example, when we're renewing as a result of a fine being paid (see RenewAccruingItemWhenPaid
2994 If C<$datedue> is the empty string, C<&AddRenewal> will calculate the due date automatically
2995 from the book's item type.
3000 my $borrowernumber = shift;
3001 my $itemnumber = shift or return;
3003 my $datedue = shift;
3004 my $lastreneweddate = shift || dt_from_string();
3005 my $skipfinecalc = shift;
3007 my $item_object = Koha::Items->find($itemnumber) or return;
3008 my $biblio = $item_object->biblio;
3009 my $issue = $item_object->checkout;
3010 my $item_unblessed = $item_object->unblessed;
3012 my $dbh = C4::Context->dbh;
3014 return unless $issue;
3016 $borrowernumber ||= $issue->borrowernumber;
3018 if ( defined $datedue && ref $datedue ne 'DateTime' ) {
3019 carp 'Invalid date passed to AddRenewal.';
3023 my $patron = Koha::Patrons->find( $borrowernumber ) or return; # FIXME Should do more than just return
3024 my $patron_unblessed = $patron->unblessed;
3026 my $circ_library = Koha::Libraries->find( _GetCircControlBranch($item_unblessed, $patron_unblessed) );
3028 my $schema = Koha::Database->schema;
3029 $schema->txn_do(sub{
3031 if ( !$skipfinecalc && C4::Context->preference('CalculateFinesOnReturn') ) {
3032 _CalculateAndUpdateFine( { issue => $issue, item => $item_unblessed, borrower => $patron_unblessed } );
3034 _FixOverduesOnReturn( $borrowernumber, $itemnumber, undef, 'RENEWED' );
3036 # If the due date wasn't specified, calculate it by adding the
3037 # book's loan length to today's date or the current due date
3038 # based on the value of the RenewalPeriodBase syspref.
3039 my $itemtype = $item_object->effective_itemtype;
3042 $datedue = (C4::Context->preference('RenewalPeriodBase') eq 'date_due') ?
3043 dt_from_string( $issue->date_due, 'sql' ) :
3045 $datedue = CalcDateDue($datedue, $itemtype, $circ_library->branchcode, $patron_unblessed, 'is a renewal');
3048 my $fees = Koha::Charges::Fees->new(
3051 library => $circ_library,
3052 item => $item_object,
3053 from_date => dt_from_string( $issue->date_due, 'sql' ),
3054 to_date => dt_from_string($datedue),
3058 # Update the issues record to have the new due date, and a new count
3059 # of how many times it has been renewed.
3060 my $renews = ( $issue->renewals || 0 ) + 1;
3061 my $sth = $dbh->prepare("UPDATE issues SET date_due = ?, renewals = ?, lastreneweddate = ?
3062 WHERE borrowernumber=?
3066 $sth->execute( $datedue->strftime('%Y-%m-%d %H:%M'), $renews, $lastreneweddate, $borrowernumber, $itemnumber );
3068 # Update the renewal count on the item, and tell zebra to reindex
3069 $renews = ( $item_object->renewals || 0 ) + 1;
3070 $item_object->renewals($renews);
3071 $item_object->onloan($datedue);
3072 $item_object->store({ log_action => 0 });
3074 # Charge a new rental fee, if applicable
3075 my ( $charge, $type ) = GetIssuingCharges( $itemnumber, $borrowernumber );
3076 if ( $charge > 0 ) {
3077 AddIssuingCharge($issue, $charge, 'RENT_RENEW');
3080 # Charge a new accumulate rental fee, if applicable
3081 my $itemtype_object = Koha::ItemTypes->find( $itemtype );
3082 if ( $itemtype_object ) {
3083 my $accumulate_charge = $fees->accumulate_rentalcharge();
3084 if ( $accumulate_charge > 0 ) {
3085 AddIssuingCharge( $issue, $accumulate_charge, 'RENT_DAILY_RENEW' )
3087 $charge += $accumulate_charge;
3090 # Send a renewal slip according to checkout alert preferencei
3091 if ( C4::Context->preference('RenewalSendNotice') eq '1' ) {
3092 my $circulation_alert = 'C4::ItemCirculationAlertPreference';
3094 branchcode => $branch,
3095 categorycode => $patron->categorycode,
3096 item_type => $itemtype,
3097 notification => 'CHECKOUT',
3099 if ( $circulation_alert->is_enabled_for( \%conditions ) ) {
3100 SendCirculationAlert(
3103 item => $item_unblessed,
3104 borrower => $patron->unblessed,
3111 # Remove any OVERDUES related debarment if the borrower has no overdues
3113 && $patron->is_debarred
3114 && ! $patron->has_overdues
3115 && @{ GetDebarments({ borrowernumber => $borrowernumber, type => 'OVERDUES' }) }
3117 DelUniqueDebarment({ borrowernumber => $borrowernumber, type => 'OVERDUES' });
3120 # Add the renewal to stats
3123 branch => $item_object->renewal_branchcode({branch => $branch}),
3126 itemnumber => $itemnumber,
3127 itemtype => $itemtype,
3128 location => $item_object->location,
3129 borrowernumber => $borrowernumber,
3130 ccode => $item_object->ccode,
3135 logaction("CIRCULATION", "RENEWAL", $borrowernumber, $itemnumber) if C4::Context->preference("RenewalLog");
3137 _after_circ_actions(
3139 action => 'renewal',
3141 checkout => $issue->get_from_storage
3144 ) if C4::Context->config("enable_plugins");
3151 # check renewal status
3152 my ( $bornum, $itemno ) = @_;
3153 my $dbh = C4::Context->dbh;
3155 my $renewsallowed = 0;
3158 my $patron = Koha::Patrons->find( $bornum );
3159 my $item = Koha::Items->find($itemno);
3161 return (0, 0, 0) unless $patron or $item; # Wrong call, no renewal allowed
3163 # Look in the issues table for this item, lent to this borrower,
3164 # and not yet returned.
3166 # FIXME - I think this function could be redone to use only one SQL call.
3167 my $sth = $dbh->prepare(
3168 "select * from issues
3169 where (borrowernumber = ?)
3170 and (itemnumber = ?)"
3172 $sth->execute( $bornum, $itemno );
3173 my $data = $sth->fetchrow_hashref;
3174 $renewcount = $data->{'renewals'} if $data->{'renewals'};
3175 # $item and $borrower should be calculated
3176 my $branchcode = _GetCircControlBranch($item->unblessed, $patron->unblessed);
3178 my $rule = Koha::CirculationRules->get_effective_rule(
3180 categorycode => $patron->categorycode,
3181 itemtype => $item->effective_itemtype,
3182 branchcode => $branchcode,
3183 rule_name => 'renewalsallowed',
3187 $renewsallowed = $rule ? $rule->rule_value : 0;
3188 $renewsleft = $renewsallowed - $renewcount;
3189 if($renewsleft < 0){ $renewsleft = 0; }
3190 return ( $renewcount, $renewsallowed, $renewsleft );
3193 =head2 GetSoonestRenewDate
3195 $NoRenewalBeforeThisDate = &GetSoonestRenewDate($borrowernumber, $itemnumber);
3197 Find out the soonest possible renew date of a borrowed item.
3199 C<$borrowernumber> is the borrower number of the patron who currently
3200 has the item on loan.
3202 C<$itemnumber> is the number of the item to renew.
3204 C<$GetSoonestRenewDate> returns the DateTime of the soonest possible
3205 renew date, based on the value "No renewal before" of the applicable
3206 issuing rule. Returns the current date if the item can already be
3207 renewed, and returns undefined if the borrower, loan, or item
3212 sub GetSoonestRenewDate {
3213 my ( $borrowernumber, $itemnumber ) = @_;
3215 my $dbh = C4::Context->dbh;
3217 my $item = Koha::Items->find($itemnumber) or return;
3218 my $itemissue = $item->checkout or return;
3220 $borrowernumber ||= $itemissue->borrowernumber;
3221 my $patron = Koha::Patrons->find( $borrowernumber )
3224 my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
3225 my $issuing_rule = Koha::CirculationRules->get_effective_rules(
3226 { categorycode => $patron->categorycode,
3227 itemtype => $item->effective_itemtype,
3228 branchcode => $branchcode,
3236 my $now = dt_from_string;
3237 return $now unless $issuing_rule;
3239 if ( defined $issuing_rule->{norenewalbefore}
3240 and $issuing_rule->{norenewalbefore} ne "" )
3242 my $soonestrenewal =
3243 dt_from_string( $itemissue->date_due )->subtract(
3244 $issuing_rule->{lengthunit} => $issuing_rule->{norenewalbefore} );
3246 if ( C4::Context->preference('NoRenewalBeforePrecision') eq 'date'
3247 and $issuing_rule->{lengthunit} eq 'days' )
3249 $soonestrenewal->truncate( to => 'day' );
3251 return $soonestrenewal if $now < $soonestrenewal;
3256 =head2 GetLatestAutoRenewDate
3258 $NoAutoRenewalAfterThisDate = &GetLatestAutoRenewDate($borrowernumber, $itemnumber);
3260 Find out the latest possible auto renew date of a borrowed item.
3262 C<$borrowernumber> is the borrower number of the patron who currently
3263 has the item on loan.
3265 C<$itemnumber> is the number of the item to renew.
3267 C<$GetLatestAutoRenewDate> returns the DateTime of the latest possible
3268 auto renew date, based on the value "No auto renewal after" and the "No auto
3269 renewal after (hard limit) of the applicable issuing rule.
3270 Returns undef if there is no date specify in the circ rules or if the patron, loan,
3271 or item cannot be found.
3275 sub GetLatestAutoRenewDate {
3276 my ( $borrowernumber, $itemnumber ) = @_;
3278 my $dbh = C4::Context->dbh;
3280 my $item = Koha::Items->find($itemnumber) or return;
3281 my $itemissue = $item->checkout or return;
3283 $borrowernumber ||= $itemissue->borrowernumber;
3284 my $patron = Koha::Patrons->find( $borrowernumber )
3287 my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
3288 my $circulation_rules = Koha::CirculationRules->get_effective_rules(
3290 categorycode => $patron->categorycode,
3291 itemtype => $item->effective_itemtype,
3292 branchcode => $branchcode,
3294 'no_auto_renewal_after',
3295 'no_auto_renewal_after_hard_limit',
3301 return unless $circulation_rules;
3303 if ( not $circulation_rules->{no_auto_renewal_after}
3304 or $circulation_rules->{no_auto_renewal_after} eq '' )
3305 and ( not $circulation_rules->{no_auto_renewal_after_hard_limit}
3306 or $circulation_rules->{no_auto_renewal_after_hard_limit} eq '' );
3308 my $maximum_renewal_date;
3309 if ( $circulation_rules->{no_auto_renewal_after} ) {
3310 $maximum_renewal_date = dt_from_string($itemissue->issuedate);
3311 $maximum_renewal_date->add(
3312 $circulation_rules->{lengthunit} => $circulation_rules->{no_auto_renewal_after}
3316 if ( $circulation_rules->{no_auto_renewal_after_hard_limit} ) {
3317 my $dt = dt_from_string( $circulation_rules->{no_auto_renewal_after_hard_limit} );
3318 $maximum_renewal_date = $dt if not $maximum_renewal_date or $maximum_renewal_date > $dt;
3320 return $maximum_renewal_date;
3324 =head2 GetIssuingCharges
3326 ($charge, $item_type) = &GetIssuingCharges($itemnumber, $borrowernumber);
3328 Calculate how much it would cost for a given patron to borrow a given
3329 item, including any applicable discounts.
3331 C<$itemnumber> is the item number of item the patron wishes to borrow.
3333 C<$borrowernumber> is the patron's borrower number.
3335 C<&GetIssuingCharges> returns two values: C<$charge> is the rental charge,
3336 and C<$item_type> is the code for the item's item type (e.g., C<VID>
3341 sub GetIssuingCharges {
3343 # calculate charges due
3344 my ( $itemnumber, $borrowernumber ) = @_;
3346 my $dbh = C4::Context->dbh;
3349 # Get the book's item type and rental charge (via its biblioitem).
3350 my $charge_query = 'SELECT itemtypes.itemtype,rentalcharge FROM items
3351 LEFT JOIN biblioitems ON biblioitems.biblioitemnumber = items.biblioitemnumber';
3352 $charge_query .= (C4::Context->preference('item-level_itypes'))
3353 ? ' LEFT JOIN itemtypes ON items.itype = itemtypes.itemtype'
3354 : ' LEFT JOIN itemtypes ON biblioitems.itemtype = itemtypes.itemtype';
3356 $charge_query .= ' WHERE items.itemnumber =?';
3358 my $sth = $dbh->prepare($charge_query);
3359 $sth->execute($itemnumber);
3360 if ( my $item_data = $sth->fetchrow_hashref ) {
3361 $item_type = $item_data->{itemtype};
3362 $charge = $item_data->{rentalcharge};
3363 my $branch = C4::Context::mybranch();
3364 my $patron = Koha::Patrons->find( $borrowernumber );
3365 my $discount = _get_discount_from_rule($patron->categorycode, $branch, $item_type);
3367 # We may have multiple rules so get the most specific
3368 $charge = ( $charge * ( 100 - $discount ) ) / 100;
3371 $charge = sprintf '%.2f', $charge; # ensure no fractions of a penny returned
3375 return ( $charge, $item_type );
3378 # Select most appropriate discount rule from those returned
3379 sub _get_discount_from_rule {
3380 my ($categorycode, $branchcode, $itemtype) = @_;
3382 # Set search precedences
3385 branchcode => $branchcode,
3386 itemtype => $itemtype,
3387 categorycode => $categorycode,
3390 branchcode => undef,
3391 categorycode => $categorycode,
3392 itemtype => $itemtype,
3395 branchcode => $branchcode,
3396 categorycode => $categorycode,
3400 branchcode => undef,
3401 categorycode => $categorycode,
3406 foreach my $params (@params) {
3407 my $rule = Koha::CirculationRules->search(
3409 rule_name => 'rentaldiscount',
3414 return $rule->rule_value if $rule;
3421 =head2 AddIssuingCharge
3423 &AddIssuingCharge( $checkout, $charge, $type )
3427 sub AddIssuingCharge {
3428 my ( $checkout, $charge, $type ) = @_;
3430 # FIXME What if checkout does not exist?
3432 my $account = Koha::Account->new({ patron_id => $checkout->borrowernumber });
3433 my $accountline = $account->add_debit(
3437 user_id => C4::Context->userenv ? C4::Context->userenv->{'number'} : undef,
3438 library_id => C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef,
3439 interface => C4::Context->interface,
3441 item_id => $checkout->itemnumber,
3442 issue_id => $checkout->issue_id,
3449 GetTransfers($itemnumber);
3454 my ($itemnumber) = @_;
3456 my $dbh = C4::Context->dbh;
3463 FROM branchtransfers
3464 WHERE itemnumber = ?
3465 AND datearrived IS NULL
3467 my $sth = $dbh->prepare($query);
3468 $sth->execute($itemnumber);
3469 my @row = $sth->fetchrow_array();
3473 =head2 GetTransfersFromTo
3475 @results = GetTransfersFromTo($frombranch,$tobranch);
3477 Returns the list of pending transfers between $from and $to branch
3481 sub GetTransfersFromTo {
3482 my ( $frombranch, $tobranch ) = @_;
3483 return unless ( $frombranch && $tobranch );
3484 my $dbh = C4::Context->dbh;
3486 SELECT branchtransfer_id,itemnumber,datesent,frombranch
3487 FROM branchtransfers
3490 AND datearrived IS NULL
3492 my $sth = $dbh->prepare($query);
3493 $sth->execute( $frombranch, $tobranch );
3496 while ( my $data = $sth->fetchrow_hashref ) {
3497 push @gettransfers, $data;
3499 return (@gettransfers);
3502 =head2 DeleteTransfer
3504 &DeleteTransfer($itemnumber);
3508 sub DeleteTransfer {
3509 my ($itemnumber) = @_;
3510 return unless $itemnumber;
3511 my $dbh = C4::Context->dbh;
3512 my $sth = $dbh->prepare(
3513 "DELETE FROM branchtransfers
3515 AND datearrived IS NULL "
3517 return $sth->execute($itemnumber);
3520 =head2 SendCirculationAlert
3522 Send out a C<check-in> or C<checkout> alert using the messaging system.
3530 Valid values for this parameter are: C<CHECKIN> and C<CHECKOUT>.
3534 Hashref of information about the item being checked in or out.
3538 Hashref of information about the borrower of the item.
3542 The branchcode from where the checkout or check-in took place.
3548 SendCirculationAlert({
3551 borrower => $borrower,
3557 sub SendCirculationAlert {
3559 my ($type, $item, $borrower, $branch) =
3560 ($opts->{type}, $opts->{item}, $opts->{borrower}, $opts->{branch});
3561 my %message_name = (
3562 CHECKIN => 'Item_Check_in',
3563 CHECKOUT => 'Item_Checkout',
3564 RENEWAL => 'Item_Checkout',
3566 my $borrower_preferences = C4::Members::Messaging::GetMessagingPreferences({
3567 borrowernumber => $borrower->{borrowernumber},
3568 message_name => $message_name{$type},
3570 my $issues_table = ( $type eq 'CHECKOUT' || $type eq 'RENEWAL' ) ? 'issues' : 'old_issues';
3572 my $schema = Koha::Database->new->schema;
3573 my @transports = keys %{ $borrower_preferences->{transports} };
3575 # From the MySQL doc:
3576 # LOCK TABLES is not transaction-safe and implicitly commits any active transaction before attempting to lock the tables.
3577 # If the LOCK/UNLOCK statements are executed from tests, the current transaction will be committed.
3578 # To avoid that we need to guess if this code is execute from tests or not (yes it is a bit hacky)
3579 my $do_not_lock = ( exists $ENV{_} && $ENV{_} =~ m|prove| ) || $ENV{KOHA_TESTING};
3581 for my $mtt (@transports) {
3582 my $letter = C4::Letters::GetPreparedLetter (
3583 module => 'circulation',
3584 letter_code => $type,
3585 branchcode => $branch,
3586 message_transport_type => $mtt,
3587 lang => $borrower->{lang},
3589 $issues_table => $item->{itemnumber},
3590 'items' => $item->{itemnumber},
3591 'biblio' => $item->{biblionumber},
3592 'biblioitems' => $item->{biblionumber},
3593 'borrowers' => $borrower,
3594 'branches' => $branch,
3598 $schema->storage->txn_begin;
3599 C4::Context->dbh->do(q|LOCK TABLE message_queue READ|) unless $do_not_lock;
3600 C4::Context->dbh->do(q|LOCK TABLE message_queue WRITE|) unless $do_not_lock;
3601 my $message = C4::Message->find_last_message($borrower, $type, $mtt);
3602 unless ( $message ) {
3603 C4::Context->dbh->do(q|UNLOCK TABLES|) unless $do_not_lock;
3604 C4::Message->enqueue($letter, $borrower, $mtt);
3606 $message->append($letter);
3609 C4::Context->dbh->do(q|UNLOCK TABLES|) unless $do_not_lock;
3610 $schema->storage->txn_commit;
3616 =head2 updateWrongTransfer
3618 $items = updateWrongTransfer($itemNumber,$borrowernumber,$waitingAtLibrary,$FromLibrary);
3620 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
3624 sub updateWrongTransfer {
3625 my ( $itemNumber,$waitingAtLibrary,$FromLibrary ) = @_;
3626 my $dbh = C4::Context->dbh;
3627 # first step validate the actual line of transfert .
3630 "update branchtransfers set datearrived = now(),tobranch=?,comments='wrongtransfer' where itemnumber= ? AND datearrived IS NULL"
3632 $sth->execute($FromLibrary,$itemNumber);
3634 # second step create a new line of branchtransfer to the right location .
3635 ModItemTransfer($itemNumber, $FromLibrary, $waitingAtLibrary);
3637 #third step changing holdingbranch of item
3638 my $item = Koha::Items->find($itemNumber)->holdingbranch($FromLibrary)->store;
3643 $newdatedue = CalcDateDue($startdate,$itemtype,$branchcode,$borrower);
3645 this function calculates the due date given the start date and configured circulation rules,
3646 checking against the holidays calendar as per the daysmode circulation rule.
3647 C<$startdate> = DateTime object representing start date of loan period (assumed to be today)
3648 C<$itemtype> = itemtype code of item in question
3649 C<$branch> = location whose calendar to use
3650 C<$borrower> = Borrower object
3651 C<$isrenewal> = Boolean: is true if we want to calculate the date due for a renewal. Else is false.
3656 my ( $startdate, $itemtype, $branch, $borrower, $isrenewal ) = @_;
3660 # loanlength now a href
3662 GetLoanLength( $borrower->{'categorycode'}, $itemtype, $branch );
3664 my $length_key = ( $isrenewal and defined $loanlength->{renewalperiod} )
3670 if (ref $startdate ne 'DateTime' ) {
3671 $datedue = dt_from_string($datedue);
3673 $datedue = $startdate->clone;
3676 $datedue = dt_from_string()->truncate( to => 'minute' );
3680 my $daysmode = Koha::CirculationRules->get_effective_daysmode(
3682 categorycode => $borrower->{categorycode},
3683 itemtype => $itemtype,
3684 branchcode => $branch,
3688 # calculate the datedue as normal
3689 if ( $daysmode eq 'Days' )
3690 { # ignoring calendar
3691 if ( $loanlength->{lengthunit} eq 'hours' ) {
3692 $datedue->add( hours => $loanlength->{$length_key} );
3694 $datedue->add( days => $loanlength->{$length_key} );
3695 $datedue->set_hour(23);
3696 $datedue->set_minute(59);
3700 if ($loanlength->{lengthunit} eq 'hours') {
3701 $dur = DateTime::Duration->new( hours => $loanlength->{$length_key});
3704 $dur = DateTime::Duration->new( days => $loanlength->{$length_key});
3706 my $calendar = Koha::Calendar->new( branchcode => $branch, days_mode => $daysmode );
3707 $datedue = $calendar->addDate( $datedue, $dur, $loanlength->{lengthunit} );
3708 if ($loanlength->{lengthunit} eq 'days') {
3709 $datedue->set_hour(23);
3710 $datedue->set_minute(59);
3714 # if Hard Due Dates are used, retrieve them and apply as necessary
3715 my ( $hardduedate, $hardduedatecompare ) =
3716 GetHardDueDate( $borrower->{'categorycode'}, $itemtype, $branch );
3717 if ($hardduedate) { # hardduedates are currently dates
3718 $hardduedate->truncate( to => 'minute' );
3719 $hardduedate->set_hour(23);
3720 $hardduedate->set_minute(59);
3721 my $cmp = DateTime->compare( $hardduedate, $datedue );
3723 # if the calculated due date is after the 'before' Hard Due Date (ceiling), override
3724 # if the calculated date is before the 'after' Hard Due Date (floor), override
3725 # if the hard due date is set to 'exactly', overrride
3726 if ( $hardduedatecompare == 0 || $hardduedatecompare == $cmp ) {
3727 $datedue = $hardduedate->clone;
3730 # in all other cases, keep the date due as it is
3734 # if ReturnBeforeExpiry ON the datedue can't be after borrower expirydate
3735 if ( C4::Context->preference('ReturnBeforeExpiry') ) {
3736 my $expiry_dt = dt_from_string( $borrower->{dateexpiry}, 'iso', 'floating');
3737 if( $expiry_dt ) { #skip empty expiry date..
3738 $expiry_dt->set( hour => 23, minute => 59);
3739 my $d1= $datedue->clone->set_time_zone('floating');
3740 if ( DateTime->compare( $d1, $expiry_dt ) == 1 ) {
3741 $datedue = $expiry_dt->clone->set_time_zone( C4::Context->tz );
3744 if ( $daysmode ne 'Days' ) {
3745 my $calendar = Koha::Calendar->new( branchcode => $branch, days_mode => $daysmode );
3746 if ( $calendar->is_holiday($datedue) ) {
3747 # Don't return on a closed day
3748 $datedue = $calendar->prev_open_days( $datedue, 1 );
3757 sub CheckValidBarcode{
3759 my $dbh = C4::Context->dbh;
3760 my $query=qq|SELECT count(*)
3764 my $sth = $dbh->prepare($query);
3765 $sth->execute($barcode);
3766 my $exist=$sth->fetchrow ;
3770 =head2 IsBranchTransferAllowed
3772 $allowed = IsBranchTransferAllowed( $toBranch, $fromBranch, $code );
3774 Code is either an itemtype or collection doe depending on the pref BranchTransferLimitsType
3776 Deprecated in favor of Koha::Item::Transfer::Limits->find/search and
3777 Koha::Item->can_be_transferred.
3781 sub IsBranchTransferAllowed {
3782 my ( $toBranch, $fromBranch, $code ) = @_;
3784 if ( $toBranch eq $fromBranch ) { return 1; } ## Short circuit for speed.
3786 my $limitType = C4::Context->preference("BranchTransferLimitsType");
3787 my $dbh = C4::Context->dbh;
3789 my $sth = $dbh->prepare("SELECT * FROM branch_transfer_limits WHERE toBranch = ? AND fromBranch = ? AND $limitType = ?");
3790 $sth->execute( $toBranch, $fromBranch, $code );
3791 my $limit = $sth->fetchrow_hashref();
3793 ## If a row is found, then that combination is not allowed, if no matching row is found, then the combination *is allowed*
3794 if ( $limit->{'limitId'} ) {
3801 =head2 CreateBranchTransferLimit
3803 CreateBranchTransferLimit( $toBranch, $fromBranch, $code );
3805 $code is either itemtype or collection code depending on what the pref BranchTransferLimitsType is set to.
3807 Deprecated in favor of Koha::Item::Transfer::Limit->new.
3811 sub CreateBranchTransferLimit {
3812 my ( $toBranch, $fromBranch, $code ) = @_;
3813 return unless defined($toBranch) && defined($fromBranch);
3814 my $limitType = C4::Context->preference("BranchTransferLimitsType");
3816 my $dbh = C4::Context->dbh;
3818 my $sth = $dbh->prepare("INSERT INTO branch_transfer_limits ( $limitType, toBranch, fromBranch ) VALUES ( ?, ?, ? )");
3819 return $sth->execute( $code, $toBranch, $fromBranch );
3822 =head2 DeleteBranchTransferLimits
3824 my $result = DeleteBranchTransferLimits($frombranch);
3826 Deletes all the library transfer limits for one library. Returns the
3827 number of limits deleted, 0e0 if no limits were deleted, or undef if
3828 no arguments are supplied.
3830 Deprecated in favor of Koha::Item::Transfer::Limits->search({
3831 fromBranch => $fromBranch
3836 sub DeleteBranchTransferLimits {
3838 return unless defined $branch;
3839 my $dbh = C4::Context->dbh;
3840 my $sth = $dbh->prepare("DELETE FROM branch_transfer_limits WHERE fromBranch = ?");
3841 return $sth->execute($branch);
3845 my ( $borrowernumber, $itemnum ) = @_;
3846 MarkIssueReturned( $borrowernumber, $itemnum );
3851 my ($itemnumber, $mark_lost_from, $force_mark_returned) = @_;
3853 unless ( $mark_lost_from ) {
3854 # Temporary check to avoid regressions
3855 die q|LostItem called without $mark_lost_from, check the API.|;
3859 if ( $force_mark_returned ) {
3862 my $pref = C4::Context->preference('MarkLostItemsAsReturned') // q{};
3863 $mark_returned = ( $pref =~ m|$mark_lost_from| );
3866 my $dbh = C4::Context->dbh();
3867 my $sth=$dbh->prepare("SELECT issues.*,items.*,biblio.title
3869 JOIN items USING (itemnumber)
3870 JOIN biblio USING (biblionumber)
3871 WHERE issues.itemnumber=?");
3872 $sth->execute($itemnumber);
3873 my $issues=$sth->fetchrow_hashref();
3875 # If a borrower lost the item, add a replacement cost to the their record
3876 if ( my $borrowernumber = $issues->{borrowernumber} ){
3877 my $patron = Koha::Patrons->find( $borrowernumber );
3879 my $fix = _FixOverduesOnReturn($borrowernumber, $itemnumber, C4::Context->preference('WhenLostForgiveFine'), 'LOST');
3880 defined($fix) or warn "_FixOverduesOnReturn($borrowernumber, $itemnumber...) failed!"; # zero is OK, check defined
3882 if (C4::Context->preference('WhenLostChargeReplacementFee')){
3883 C4::Accounts::chargelostitem(
3886 $issues->{'replacementprice'},
3887 sprintf( "%s %s %s",
3888 $issues->{'title'} || q{},
3889 $issues->{'barcode'} || q{},
3890 $issues->{'itemcallnumber'} || q{},
3893 #FIXME : Should probably have a way to distinguish this from an item that really was returned.
3894 #warn " $issues->{'borrowernumber'} / $itemnumber ";
3897 MarkIssueReturned($borrowernumber,$itemnumber,undef,$patron->privacy) if $mark_returned;
3900 #When item is marked lost automatically cancel its outstanding transfers and set items holdingbranch to the transfer source branch (frombranch)
3901 if (my ( $datesent,$frombranch,$tobranch ) = GetTransfers($itemnumber)) {
3902 Koha::Items->find($itemnumber)->holdingbranch($frombranch)->store;
3904 my $transferdeleted = DeleteTransfer($itemnumber);
3907 sub GetOfflineOperations {
3908 my $dbh = C4::Context->dbh;
3909 my $sth = $dbh->prepare("SELECT * FROM pending_offline_operations WHERE branchcode=? ORDER BY timestamp");
3910 $sth->execute(C4::Context->userenv->{'branch'});
3911 my $results = $sth->fetchall_arrayref({});
3915 sub GetOfflineOperation {
3916 my $operationid = shift;
3917 return unless $operationid;
3918 my $dbh = C4::Context->dbh;
3919 my $sth = $dbh->prepare("SELECT * FROM pending_offline_operations WHERE operationid=?");
3920 $sth->execute( $operationid );
3921 return $sth->fetchrow_hashref;
3924 sub AddOfflineOperation {
3925 my ( $userid, $branchcode, $timestamp, $action, $barcode, $cardnumber, $amount ) = @_;
3926 my $dbh = C4::Context->dbh;
3927 my $sth = $dbh->prepare("INSERT INTO pending_offline_operations (userid, branchcode, timestamp, action, barcode, cardnumber, amount) VALUES(?,?,?,?,?,?,?)");
3928 $sth->execute( $userid, $branchcode, $timestamp, $action, $barcode, $cardnumber, $amount );
3932 sub DeleteOfflineOperation {
3933 my $dbh = C4::Context->dbh;
3934 my $sth = $dbh->prepare("DELETE FROM pending_offline_operations WHERE operationid=?");
3935 $sth->execute( shift );
3939 sub ProcessOfflineOperation {
3940 my $operation = shift;
3943 if ( $operation->{action} eq 'return' ) {
3944 $report = ProcessOfflineReturn( $operation );
3945 } elsif ( $operation->{action} eq 'issue' ) {
3946 $report = ProcessOfflineIssue( $operation );
3947 } elsif ( $operation->{action} eq 'payment' ) {
3948 $report = ProcessOfflinePayment( $operation );
3951 DeleteOfflineOperation( $operation->{operationid} ) if $operation->{operationid};
3956 sub ProcessOfflineReturn {
3957 my $operation = shift;
3959 my $item = Koha::Items->find({barcode => $operation->{barcode}});
3962 my $itemnumber = $item->itemnumber;
3963 my $issue = GetOpenIssue( $itemnumber );
3965 my $leave_item_lost = C4::Context->preference("BlockReturnOfLostItems") ? 1 : 0;
3966 ModDateLastSeen( $itemnumber, $leave_item_lost );
3968 $issue->{borrowernumber},
3970 $operation->{timestamp},
3973 $item->onloan(undef);
3974 $item->store({ log_action => 0 });
3977 return "Item not issued.";
3980 return "Item not found.";
3984 sub ProcessOfflineIssue {
3985 my $operation = shift;
3987 my $patron = Koha::Patrons->find( { cardnumber => $operation->{cardnumber} } );
3990 my $item = Koha::Items->find({ barcode => $operation->{barcode} });
3992 return "Barcode not found.";
3994 my $itemnumber = $item->itemnumber;
3995 my $issue = GetOpenIssue( $itemnumber );
3997 if ( $issue and ( $issue->{borrowernumber} ne $patron->borrowernumber ) ) { # Item already issued to another patron mark it returned
3999 $issue->{borrowernumber},
4001 $operation->{timestamp},
4006 $operation->{'barcode'},
4009 $operation->{timestamp},
4014 return "Borrower not found.";
4018 sub ProcessOfflinePayment {
4019 my $operation = shift;
4021 my $patron = Koha::Patrons->find({ cardnumber => $operation->{cardnumber} });
4023 $patron->account->pay(
4025 amount => $operation->{amount},
4026 library_id => $operation->{branchcode},
4036 TransferSlip($user_branch, $itemnumber, $barcode, $to_branch)
4038 Returns letter hash ( see C4::Letters::GetPreparedLetter ) or undef
4043 my ($branch, $itemnumber, $barcode, $to_branch) = @_;
4047 ? Koha::Items->find($itemnumber)
4048 : Koha::Items->find( { barcode => $barcode } );
4052 return C4::Letters::GetPreparedLetter (
4053 module => 'circulation',
4054 letter_code => 'TRANSFERSLIP',
4055 branchcode => $branch,
4057 'branches' => $to_branch,
4058 'biblio' => $item->biblionumber,
4059 'items' => $item->unblessed,
4064 =head2 CheckIfIssuedToPatron
4066 CheckIfIssuedToPatron($borrowernumber, $biblionumber)
4068 Return 1 if any record item is issued to patron, otherwise return 0
4072 sub CheckIfIssuedToPatron {
4073 my ($borrowernumber, $biblionumber) = @_;
4075 my $dbh = C4::Context->dbh;
4077 SELECT COUNT(*) FROM issues
4078 LEFT JOIN items ON items.itemnumber = issues.itemnumber
4079 WHERE items.biblionumber = ?
4080 AND issues.borrowernumber = ?
4082 my $is_issued = $dbh->selectrow_array($query, {}, $biblionumber, $borrowernumber );
4083 return 1 if $is_issued;
4089 IsItemIssued( $itemnumber )
4091 Return 1 if the item is on loan, otherwise return 0
4096 my $itemnumber = shift;
4097 my $dbh = C4::Context->dbh;
4098 my $sth = $dbh->prepare(q{
4101 WHERE itemnumber = ?
4103 $sth->execute($itemnumber);
4104 return $sth->fetchrow;
4107 =head2 GetAgeRestriction
4109 my ($ageRestriction, $daysToAgeRestriction) = GetAgeRestriction($record_restrictions, $borrower);
4110 my ($ageRestriction, $daysToAgeRestriction) = GetAgeRestriction($record_restrictions);
4112 if($daysToAgeRestriction <= 0) { #Borrower is allowed to access this material, as they are older or as old as the agerestriction }
4113 if($daysToAgeRestriction > 0) { #Borrower is this many days from meeting the agerestriction }
4115 @PARAM1 the koha.biblioitems.agerestriction value, like K18, PEGI 13, ...
4116 @PARAM2 a borrower-object with koha.borrowers.dateofbirth. (OPTIONAL)
4117 @RETURNS The age restriction age in years and the days to fulfill the age restriction for the given borrower.
4118 Negative days mean the borrower has gone past the age restriction age.
4122 sub GetAgeRestriction {
4123 my ($record_restrictions, $borrower) = @_;
4124 my $markers = C4::Context->preference('AgeRestrictionMarker');
4126 return unless $record_restrictions;
4127 # Split $record_restrictions to something like FSK 16 or PEGI 6
4128 my @values = split ' ', uc($record_restrictions);
4129 return unless @values;
4131 # Search first occurrence of one of the markers
4132 my @markers = split /\|/, uc($markers);
4133 return unless @markers;
4136 my $restriction_year = 0;
4137 for my $value (@values) {
4139 for my $marker (@markers) {
4140 $marker =~ s/^\s+//; #remove leading spaces
4141 $marker =~ s/\s+$//; #remove trailing spaces
4142 if ( $marker eq $value ) {
4143 if ( $index <= $#values ) {
4144 $restriction_year += $values[$index];
4148 elsif ( $value =~ /^\Q$marker\E(\d+)$/ ) {
4150 # Perhaps it is something like "K16" (as in Finland)
4151 $restriction_year += $1;
4155 last if ( $restriction_year > 0 );
4158 #Check if the borrower is age restricted for this material and for how long.
4159 if ($restriction_year && $borrower) {
4160 if ( $borrower->{'dateofbirth'} ) {
4161 my @alloweddate = split /-/, $borrower->{'dateofbirth'};
4162 $alloweddate[0] += $restriction_year;
4164 #Prevent runime eror on leap year (invalid date)
4165 if ( ( $alloweddate[1] == 2 ) && ( $alloweddate[2] == 29 ) ) {
4166 $alloweddate[2] = 28;
4169 #Get how many days the borrower has to reach the age restriction
4170 my @Today = split /-/, dt_from_string()->ymd();
4171 my $daysToAgeRestriction = Date_to_Days(@alloweddate) - Date_to_Days(@Today);
4172 #Negative days means the borrower went past the age restriction age
4173 return ($restriction_year, $daysToAgeRestriction);
4177 return ($restriction_year);
4181 =head2 GetPendingOnSiteCheckouts
4185 sub GetPendingOnSiteCheckouts {
4186 my $dbh = C4::Context->dbh;
4187 return $dbh->selectall_arrayref(q|
4193 items.itemcallnumber,
4197 issues.date_due < NOW() AS is_overdue,
4200 borrowers.firstname,
4202 borrowers.cardnumber,
4203 borrowers.borrowernumber
4205 LEFT JOIN issues ON items.itemnumber = issues.itemnumber
4206 LEFT JOIN biblio ON items.biblionumber = biblio.biblionumber
4207 LEFT JOIN borrowers ON issues.borrowernumber = borrowers.borrowernumber
4208 WHERE issues.onsite_checkout = 1
4209 |, { Slice => {} } );
4215 my ($count, $branch, $itemtype, $ccode, $newness)
4216 = @$params{qw(count branch itemtype ccode newness)};
4218 my $dbh = C4::Context->dbh;
4221 SELECT b.biblionumber, b.title, b.author, bi.itemtype, bi.publishercode,
4222 bi.place, bi.publicationyear, b.copyrightdate, bi.pages, bi.size,
4223 i.ccode, SUM(i.issues) AS count
4225 LEFT JOIN items i ON (i.biblionumber = b.biblionumber)
4226 LEFT JOIN biblioitems bi ON (bi.biblionumber = b.biblionumber)
4229 my (@where_strs, @where_args);
4232 push @where_strs, 'i.homebranch = ?';
4233 push @where_args, $branch;
4236 if (C4::Context->preference('item-level_itypes')){
4237 push @where_strs, 'i.itype = ?';
4238 push @where_args, $itemtype;
4240 push @where_strs, 'bi.itemtype = ?';
4241 push @where_args, $itemtype;
4245 push @where_strs, 'i.ccode = ?';
4246 push @where_args, $ccode;
4249 push @where_strs, 'TO_DAYS(NOW()) - TO_DAYS(b.datecreated) <= ?';
4250 push @where_args, $newness;
4254 $query .= 'WHERE ' . join(' AND ', @where_strs);
4258 GROUP BY b.biblionumber, b.title, b.author, bi.itemtype, bi.publishercode,
4259 bi.place, bi.publicationyear, b.copyrightdate, bi.pages, bi.size,
4264 $query .= q{ ) xxx WHERE count > 0 };
4265 $count = int($count);
4267 $query .= "LIMIT $count";
4270 my $rows = $dbh->selectall_arrayref($query, { Slice => {} }, @where_args);
4275 =head2 Internal methods
4279 sub _CalculateAndUpdateFine {
4282 my $borrower = $params->{borrower};
4283 my $item = $params->{item};
4284 my $issue = $params->{issue};
4285 my $return_date = $params->{return_date};
4287 unless ($borrower) { carp "No borrower passed in!" && return; }
4288 unless ($item) { carp "No item passed in!" && return; }
4289 unless ($issue) { carp "No issue passed in!" && return; }
4291 my $datedue = dt_from_string( $issue->date_due );
4293 # we only need to calculate and change the fines if we want to do that on return
4294 # Should be on for hourly loans
4295 my $control = C4::Context->preference('CircControl');
4296 my $control_branchcode =
4297 ( $control eq 'ItemHomeLibrary' ) ? $item->{homebranch}
4298 : ( $control eq 'PatronLibrary' ) ? $borrower->{branchcode}
4299 : $issue->branchcode;
4301 my $date_returned = $return_date ? $return_date : dt_from_string();
4303 my ( $amount, $unitcounttotal, $unitcount ) =
4304 C4::Overdues::CalcFine( $item, $borrower->{categorycode}, $control_branchcode, $datedue, $date_returned );
4306 if ( C4::Context->preference('finesMode') eq 'production' ) {
4307 if ( $amount > 0 ) {
4308 C4::Overdues::UpdateFine({
4309 issue_id => $issue->issue_id,
4310 itemnumber => $issue->itemnumber,
4311 borrowernumber => $issue->borrowernumber,
4313 due => output_pref($datedue),
4316 elsif ($return_date) {
4318 # Backdated returns may have fines that shouldn't exist,
4319 # so in this case, we need to drop those fines to 0
4321 C4::Overdues::UpdateFine({
4322 issue_id => $issue->issue_id,
4323 itemnumber => $issue->itemnumber,
4324 borrowernumber => $issue->borrowernumber,
4326 due => output_pref($datedue),
4332 sub _item_denied_renewal {
4335 my $item = $params->{item};
4336 return unless $item;
4338 my $denyingrules = Koha::Config::SysPrefs->find('ItemsDeniedRenewal')->get_yaml_pref_hash();
4339 return unless $denyingrules;
4340 foreach my $field (keys %$denyingrules) {
4341 my $val = $item->$field;
4342 if( !defined $val) {
4343 if ( any { !defined $_ } @{$denyingrules->{$field}} ){
4346 } elsif (any { defined($_) && $val eq $_ } @{$denyingrules->{$field}}) {
4347 # If the results matches the values in the syspref
4348 # We return true if match found
4355 =head3 _after_circ_actions
4357 Internal method that calls the after_circ_action plugin hook on configured
4362 sub _after_circ_actions {
4365 my @plugins = Koha::Plugins->new->GetPlugins({
4366 method => 'after_circ_action',
4369 foreach my $plugin ( @plugins ) {
4371 $plugin->after_circ_action( $params );
4385 Koha Development Team <http://koha-community.org/>