C4/Circulation.pm

   1 package C4::Circulation;
   2
   3 # Copyright 2000-2002 Katipo Communications
   4 # copyright 2010 BibLibre
   5 #
   6 # This file is part of Koha.
   7 #
   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.
  12 #
  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.
  17 #
  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>.
  20
  21 use Modern::Perl;
  22 use DateTime;
  23 use POSIX qw( floor );
  24 use Koha::DateUtils;
  25 use C4::Context;
  26 use C4::Stats;
  27 use C4::Reserves;
  28 use C4::Biblio;
  29 use C4::Items;
  30 use C4::Members;
  31 use C4::Accounts;
  32 use C4::ItemCirculationAlertPreference;
  33 use C4::Message;
  34 use C4::Debug;
  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;
  39
  40 use Data::Dumper;
  41 use Koha::Account;
  42 use Koha::AuthorisedValues;
  43 use Koha::Biblioitems;
  44 use Koha::DateUtils;
  45 use Koha::Calendar;
  46 use Koha::Checkouts;
  47 use Koha::Illrequests;
  48 use Koha::Items;
  49 use Koha::Patrons;
  50 use Koha::Patron::Debarments;
  51 use Koha::Database;
  52 use Koha::Libraries;
  53 use Koha::Account::Lines;
  54 use Koha::Holds;
  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;
  62 use Koha::SearchEngine::Indexer;
  63 use Carp;
  64 use List::MoreUtils qw( uniq any );
  65 use Scalar::Util qw( looks_like_number );
  66 use Date::Calc qw(
  67   Today
  68   Today_and_Now
  69   Add_Delta_YM
  70   Add_Delta_DHMS
  71   Date_to_Days
  72   Day_of_Week
  73   Add_Delta_Days
  74 );
  75 use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
  76
  77 BEGIN {
  78         require Exporter;
  79         @ISA    = qw(Exporter);
  80
  81         # FIXME subs that should probably be elsewhere
  82         push @EXPORT, qw(
  83                 &barcodedecode
  84         &LostItem
  85         &ReturnLostItem
  86         &GetPendingOnSiteCheckouts
  87         );
  88
  89         # subs to deal with issuing a book
  90         push @EXPORT, qw(
  91                 &CanBookBeIssued
  92                 &CanBookBeRenewed
  93                 &AddIssue
  94                 &AddRenewal
  95                 &GetRenewCount
  96         &GetSoonestRenewDate
  97         &GetLatestAutoRenewDate
  98                 &GetIssuingCharges
  99         &GetBranchBorrowerCircRule
 100         &GetBranchItemRule
 101                 &GetOpenIssue
 102         &CheckIfIssuedToPatron
 103         &IsItemIssued
 104         GetTopIssues
 105         );
 106
 107         # subs to deal with returns
 108         push @EXPORT, qw(
 109                 &AddReturn
 110         &MarkIssueReturned
 111         );
 112
 113         # subs to deal with transfers
 114         push @EXPORT, qw(
 115                 &transferbook
 116                 &GetTransfers
 117                 &GetTransfersFromTo
 118                 &updateWrongTransfer
 119                 &DeleteTransfer
 120                 &IsBranchTransferAllowed
 121                 &CreateBranchTransferLimit
 122                 &DeleteBranchTransferLimits
 123         &TransferSlip
 124         );
 125
 126     # subs to deal with offline circulation
 127     push @EXPORT, qw(
 128       &GetOfflineOperations
 129       &GetOfflineOperation
 130       &AddOfflineOperation
 131       &DeleteOfflineOperation
 132       &ProcessOfflineOperation
 133     );
 134 }
 135
 136 =head1 NAME
 137
 138 C4::Circulation - Koha circulation module
 139
 140 =head1 SYNOPSIS
 141
 142 use C4::Circulation;
 143
 144 =head1 DESCRIPTION
 145
 146 The functions in this module deal with circulation, issues, and
 147 returns, as well as general information about the library.
 148 Also deals with inventory.
 149
 150 =head1 FUNCTIONS
 151
 152 =head2 barcodedecode
 153
 154   $str = &barcodedecode($barcode, [$filter]);
 155
 156 Generic filter function for barcode string.
 157 Called on every circ if the System Pref itemBarcodeInputFilter is set.
 158 Will do some manipulation of the barcode for systems that deliver a barcode
 159 to circulation.pl that differs from the barcode stored for the item.
 160 For proper functioning of this filter, calling the function on the
 161 correct barcode string (items.barcode) should return an unaltered barcode.
 162
 163 The optional $filter argument is to allow for testing or explicit
 164 behavior that ignores the System Pref.  Valid values are the same as the
 165 System Pref options.
 166
 167 =cut
 168
 169 # FIXME -- the &decode fcn below should be wrapped into this one.
 170 # FIXME -- these plugins should be moved out of Circulation.pm
 171 #
 172 sub barcodedecode {
 173     my ($barcode, $filter) = @_;
 174     my $branch = C4::Context::mybranch();
 175     $filter = C4::Context->preference('itemBarcodeInputFilter') unless $filter;
 176     $filter or return $barcode;     # ensure filter is defined, else return untouched barcode
 177         if ($filter eq 'whitespace') {
 178                 $barcode =~ s/\s//g;
 179         } elsif ($filter eq 'cuecat') {
 180                 chomp($barcode);
 181             my @fields = split( /\./, $barcode );
 182             my @results = map( decode($_), @fields[ 1 .. $#fields ] );
 183             ($#results == 2) and return $results[2];
 184         } elsif ($filter eq 'T-prefix') {
 185                 if ($barcode =~ /^[Tt](\d)/) {
 186                         (defined($1) and $1 eq '0') and return $barcode;
 187             $barcode = substr($barcode, 2) + 0;     # FIXME: probably should be substr($barcode, 1)
 188                 }
 189         return sprintf("T%07d", $barcode);
 190         # FIXME: $barcode could be "T1", causing warning: substr outside of string
 191         # Why drop the nonzero digit after the T?
 192         # Why pass non-digits (or empty string) to "T%07d"?
 193         } elsif ($filter eq 'libsuite8') {
 194                 unless($barcode =~ m/^($branch)-/i){    #if barcode starts with branch code its in Koha style. Skip it.
 195                         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
 196                                 $barcode =~ s/^[0]*(\d+)$/$branch-b-$1/i;
 197                         }else{
 198                                 $barcode =~ s/^(\D+)[0]*(\d+)$/$branch-$1-$2/i;
 199                         }
 200                 }
 201     } elsif ($filter eq 'EAN13') {
 202         my $ean = CheckDigits('ean');
 203         if ( $ean->is_valid($barcode) ) {
 204             #$barcode = sprintf('%013d',$barcode); # this doesn't work on 32-bit systems
 205             $barcode = '0' x ( 13 - length($barcode) ) . $barcode;
 206         } else {
 207             warn "# [$barcode] not valid EAN-13/UPC-A\n";
 208         }
 209         }
 210     return $barcode;    # return barcode, modified or not
 211 }
 212
 213 =head2 decode
 214
 215   $str = &decode($chunk);
 216
 217 Decodes a segment of a string emitted by a CueCat barcode scanner and
 218 returns it.
 219
 220 FIXME: Should be replaced with Barcode::Cuecat from CPAN
 221 or Javascript based decoding on the client side.
 222
 223 =cut
 224
 225 sub decode {
 226     my ($encoded) = @_;
 227     my $seq =
 228       'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-';
 229     my @s = map { index( $seq, $_ ); } split( //, $encoded );
 230     my $l = ( $#s + 1 ) % 4;
 231     if ($l) {
 232         if ( $l == 1 ) {
 233             # warn "Error: Cuecat decode parsing failed!";
 234             return;
 235         }
 236         $l = 4 - $l;
 237         $#s += $l;
 238     }
 239     my $r = '';
 240     while ( $#s >= 0 ) {
 241         my $n = ( ( $s[0] << 6 | $s[1] ) << 6 | $s[2] ) << 6 | $s[3];
 242         $r .=
 243             chr( ( $n >> 16 ) ^ 67 )
 244          .chr( ( $n >> 8 & 255 ) ^ 67 )
 245          .chr( ( $n & 255 ) ^ 67 );
 246         @s = @s[ 4 .. $#s ];
 247     }
 248     $r = substr( $r, 0, length($r) - $l );
 249     return $r;
 250 }
 251
 252 =head2 transferbook
 253
 254   ($dotransfer, $messages, $iteminformation) = &transferbook($newbranch,
 255                                             $barcode, $ignore_reserves, $trigger);
 256
 257 Transfers an item to a new branch. If the item is currently on loan, it is automatically returned before the actual transfer.
 258
 259 C<$newbranch> is the code for the branch to which the item should be transferred.
 260
 261 C<$barcode> is the barcode of the item to be transferred.
 262
 263 If C<$ignore_reserves> is true, C<&transferbook> ignores reserves.
 264 Otherwise, if an item is reserved, the transfer fails.
 265
 266 C<$trigger> is the enum value for what triggered the transfer.
 267
 268 Returns three values:
 269
 270 =over
 271
 272 =item $dotransfer
 273
 274 is true if the transfer was successful.
 275
 276 =item $messages
 277
 278 is a reference-to-hash which may have any of the following keys:
 279
 280 =over
 281
 282 =item C<BadBarcode>
 283
 284 There is no item in the catalog with the given barcode. The value is C<$barcode>.
 285
 286 =item C<DestinationEqualsHolding>
 287
 288 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.
 289
 290 =item C<WasReturned>
 291
 292 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.
 293
 294 =item C<ResFound>
 295
 296 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>.
 297
 298 =item C<WasTransferred>
 299
 300 The item was eligible to be transferred. Barring problems communicating with the database, the transfer should indeed have succeeded. The value should be ignored.
 301
 302 =back
 303
 304 =back
 305
 306 =cut
 307
 308 sub transferbook {
 309     my ( $tbr, $barcode, $ignoreRs, $trigger ) = @_;
 310     my $messages;
 311     my $dotransfer      = 1;
 312     my $item = Koha::Items->find( { barcode => $barcode } );
 313
 314     # bad barcode..
 315     unless ( $item ) {
 316         $messages->{'BadBarcode'} = $barcode;
 317         $dotransfer = 0;
 318         return ( $dotransfer, $messages );
 319     }
 320
 321     my $itemnumber = $item->itemnumber;
 322     # get branches of book...
 323     my $hbr = $item->homebranch;
 324     my $fbr = $item->holdingbranch;
 325
 326     # if using Branch Transfer Limits
 327     if ( C4::Context->preference("UseBranchTransferLimits") == 1 ) {
 328         my $code = C4::Context->preference("BranchTransferLimitsType") eq 'ccode' ? $item->ccode : $item->biblio->biblioitem->itemtype; # BranchTransferLimitsType is 'ccode' or 'itemtype'
 329         if ( C4::Context->preference("item-level_itypes") && C4::Context->preference("BranchTransferLimitsType") eq 'itemtype' ) {
 330             if ( ! IsBranchTransferAllowed( $tbr, $fbr, $item->itype ) ) {
 331                 $messages->{'NotAllowed'} = $tbr . "::" . $item->itype;
 332                 $dotransfer = 0;
 333             }
 334         } elsif ( ! IsBranchTransferAllowed( $tbr, $fbr, $code ) ) {
 335             $messages->{'NotAllowed'} = $tbr . "::" . $code;
 336             $dotransfer = 0;
 337         }
 338     }
 339
 340     # can't transfer book if is already there....
 341     if ( $fbr eq $tbr ) {
 342         $messages->{'DestinationEqualsHolding'} = 1;
 343         $dotransfer = 0;
 344     }
 345
 346     # check if it is still issued to someone, return it...
 347     my $issue = Koha::Checkouts->find({ itemnumber => $itemnumber });
 348     if ( $issue ) {
 349         AddReturn( $barcode, $fbr );
 350         $messages->{'WasReturned'} = $issue->borrowernumber;
 351     }
 352
 353     # find reserves.....
 354     # That'll save a database query.
 355     my ( $resfound, $resrec, undef ) =
 356       CheckReserves( $itemnumber );
 357     if ( $resfound and not $ignoreRs ) {
 358         $resrec->{'ResFound'} = $resfound;
 359         $messages->{'ResFound'} = $resrec;
 360         $dotransfer = 1;
 361     }
 362
 363     #actually do the transfer....
 364     if ($dotransfer) {
 365         ModItemTransfer( $itemnumber, $fbr, $tbr, $trigger );
 366
 367         # don't need to update MARC anymore, we do it in batch now
 368         $messages->{'WasTransfered'} = 1;
 369
 370     }
 371     ModDateLastSeen( $itemnumber );
 372     return ( $dotransfer, $messages );
 373 }
 374
 375
 376 sub TooMany {
 377     my $borrower        = shift;
 378     my $item_object = shift;
 379     my $params = shift;
 380     my $onsite_checkout = $params->{onsite_checkout} || 0;
 381     my $switch_onsite_checkout = $params->{switch_onsite_checkout} || 0;
 382     my $cat_borrower    = $borrower->{'categorycode'};
 383     my $dbh             = C4::Context->dbh;
 384         my $branch;
 385         # Get which branchcode we need
 386     $branch = _GetCircControlBranch($item_object->unblessed,$borrower);
 387     my $type = $item_object->effective_itemtype;
 388
 389     # given branch, patron category, and item type, determine
 390     # applicable issuing rule
 391     my $maxissueqty_rule = Koha::CirculationRules->get_effective_rule(
 392         {
 393             categorycode => $cat_borrower,
 394             itemtype     => $type,
 395             branchcode   => $branch,
 396             rule_name    => 'maxissueqty',
 397         }
 398     );
 399     my $maxonsiteissueqty_rule = Koha::CirculationRules->get_effective_rule(
 400         {
 401             categorycode => $cat_borrower,
 402             itemtype     => $type,
 403             branchcode   => $branch,
 404             rule_name    => 'maxonsiteissueqty',
 405         }
 406     );
 407
 408
 409     # if a rule is found and has a loan limit set, count
 410     # how many loans the patron already has that meet that
 411     # rule
 412     if (defined($maxissueqty_rule) and $maxissueqty_rule->rule_value ne '') {
 413         my @bind_params;
 414         my $count_query = q|
 415             SELECT COUNT(*) AS total, COALESCE(SUM(onsite_checkout), 0) AS onsite_checkouts
 416             FROM issues
 417             JOIN items USING (itemnumber)
 418         |;
 419
 420         my $rule_itemtype = $maxissueqty_rule->itemtype;
 421         unless ($rule_itemtype) {
 422             # matching rule has the default item type, so count only
 423             # those existing loans that don't fall under a more
 424             # specific rule
 425             if (C4::Context->preference('item-level_itypes')) {
 426                 $count_query .= " WHERE items.itype NOT IN (
 427                                     SELECT itemtype FROM circulation_rules
 428                                     WHERE branchcode = ?
 429                                     AND   (categorycode = ? OR categorycode = ?)
 430                                     AND   itemtype IS NOT NULL
 431                                     AND   rule_name = 'maxissueqty'
 432                                   ) ";
 433             } else {
 434                 $count_query .= " JOIN  biblioitems USING (biblionumber)
 435                                   WHERE biblioitems.itemtype NOT IN (
 436                                     SELECT itemtype FROM circulation_rules
 437                                     WHERE branchcode = ?
 438                                     AND   (categorycode = ? OR categorycode = ?)
 439                                     AND   itemtype IS NOT NULL
 440                                     AND   rule_name = 'maxissueqty'
 441                                   ) ";
 442             }
 443             push @bind_params, $maxissueqty_rule->branchcode;
 444             push @bind_params, $maxissueqty_rule->categorycode;
 445             push @bind_params, $cat_borrower;
 446         } else {
 447             # rule has specific item type, so count loans of that
 448             # specific item type
 449             if (C4::Context->preference('item-level_itypes')) {
 450                 $count_query .= " WHERE items.itype = ? ";
 451             } else {
 452                 $count_query .= " JOIN  biblioitems USING (biblionumber)
 453                                   WHERE biblioitems.itemtype= ? ";
 454             }
 455             push @bind_params, $type;
 456         }
 457
 458         $count_query .= " AND borrowernumber = ? ";
 459         push @bind_params, $borrower->{'borrowernumber'};
 460         my $rule_branch = $maxissueqty_rule->branchcode;
 461         if ($rule_branch) {
 462             if (C4::Context->preference('CircControl') eq 'PickupLibrary') {
 463                 $count_query .= " AND issues.branchcode = ? ";
 464                 push @bind_params, $rule_branch;
 465             } elsif (C4::Context->preference('CircControl') eq 'PatronLibrary') {
 466                 ; # if branch is the patron's home branch, then count all loans by patron
 467             } else {
 468                 $count_query .= " AND items.homebranch = ? ";
 469                 push @bind_params, $rule_branch;
 470             }
 471         }
 472
 473         my ( $checkout_count, $onsite_checkout_count ) = $dbh->selectrow_array( $count_query, {}, @bind_params );
 474
 475         my $max_checkouts_allowed = $maxissueqty_rule ? $maxissueqty_rule->rule_value : undef;
 476         my $max_onsite_checkouts_allowed = $maxonsiteissueqty_rule ? $maxonsiteissueqty_rule->rule_value : undef;
 477
 478         if ( $onsite_checkout and $max_onsite_checkouts_allowed ne '' ) {
 479             if ( $onsite_checkout_count >= $max_onsite_checkouts_allowed )  {
 480                 return {
 481                     reason => 'TOO_MANY_ONSITE_CHECKOUTS',
 482                     count => $onsite_checkout_count,
 483                     max_allowed => $max_onsite_checkouts_allowed,
 484                 }
 485             }
 486         }
 487         if ( C4::Context->preference('ConsiderOnSiteCheckoutsAsNormalCheckouts') ) {
 488             my $delta = $switch_onsite_checkout ? 1 : 0;
 489             if ( $checkout_count >= $max_checkouts_allowed + $delta ) {
 490                 return {
 491                     reason => 'TOO_MANY_CHECKOUTS',
 492                     count => $checkout_count,
 493                     max_allowed => $max_checkouts_allowed,
 494                 };
 495             }
 496         } elsif ( not $onsite_checkout ) {
 497             if ( $checkout_count - $onsite_checkout_count >= $max_checkouts_allowed )  {
 498                 return {
 499                     reason => 'TOO_MANY_CHECKOUTS',
 500                     count => $checkout_count - $onsite_checkout_count,
 501                     max_allowed => $max_checkouts_allowed,
 502                 };
 503             }
 504         }
 505     }
 506
 507     # Now count total loans against the limit for the branch
 508     my $branch_borrower_circ_rule = GetBranchBorrowerCircRule($branch, $cat_borrower);
 509     if (defined($branch_borrower_circ_rule->{patron_maxissueqty}) and $branch_borrower_circ_rule->{patron_maxissueqty} ne '') {
 510         my @bind_params = ();
 511         my $branch_count_query = q|
 512             SELECT COUNT(*) AS total, COALESCE(SUM(onsite_checkout), 0) AS onsite_checkouts
 513             FROM issues
 514             JOIN items USING (itemnumber)
 515             WHERE borrowernumber = ?
 516         |;
 517         push @bind_params, $borrower->{borrowernumber};
 518
 519         if (C4::Context->preference('CircControl') eq 'PickupLibrary') {
 520             $branch_count_query .= " AND issues.branchcode = ? ";
 521             push @bind_params, $branch;
 522         } elsif (C4::Context->preference('CircControl') eq 'PatronLibrary') {
 523             ; # if branch is the patron's home branch, then count all loans by patron
 524         } else {
 525             $branch_count_query .= " AND items.homebranch = ? ";
 526             push @bind_params, $branch;
 527         }
 528         my ( $checkout_count, $onsite_checkout_count ) = $dbh->selectrow_array( $branch_count_query, {}, @bind_params );
 529         my $max_checkouts_allowed = $branch_borrower_circ_rule->{patron_maxissueqty};
 530         my $max_onsite_checkouts_allowed = $branch_borrower_circ_rule->{patron_maxonsiteissueqty};
 531
 532         if ( $onsite_checkout and $max_onsite_checkouts_allowed ne '' ) {
 533             if ( $onsite_checkout_count >= $max_onsite_checkouts_allowed )  {
 534                 return {
 535                     reason => 'TOO_MANY_ONSITE_CHECKOUTS',
 536                     count => $onsite_checkout_count,
 537                     max_allowed => $max_onsite_checkouts_allowed,
 538                 }
 539             }
 540         }
 541         if ( C4::Context->preference('ConsiderOnSiteCheckoutsAsNormalCheckouts') ) {
 542             my $delta = $switch_onsite_checkout ? 1 : 0;
 543             if ( $checkout_count >= $max_checkouts_allowed + $delta ) {
 544                 return {
 545                     reason => 'TOO_MANY_CHECKOUTS',
 546                     count => $checkout_count,
 547                     max_allowed => $max_checkouts_allowed,
 548                 };
 549             }
 550         } elsif ( not $onsite_checkout ) {
 551             if ( $checkout_count - $onsite_checkout_count >= $max_checkouts_allowed )  {
 552                 return {
 553                     reason => 'TOO_MANY_CHECKOUTS',
 554                     count => $checkout_count - $onsite_checkout_count,
 555                     max_allowed => $max_checkouts_allowed,
 556                 };
 557             }
 558         }
 559     }
 560
 561     if ( not defined( $maxissueqty_rule ) and not defined($branch_borrower_circ_rule->{patron_maxissueqty}) ) {
 562         return { reason => 'NO_RULE_DEFINED', max_allowed => 0 };
 563     }
 564
 565     # OK, the patron can issue !!!
 566     return;
 567 }
 568
 569 =head2 CanBookBeIssued
 570
 571   ( $issuingimpossible, $needsconfirmation, [ $alerts ] ) =  CanBookBeIssued( $patron,
 572                       $barcode, $duedate, $inprocess, $ignore_reserves, $params );
 573
 574 Check if a book can be issued.
 575
 576 C<$issuingimpossible> and C<$needsconfirmation> are hashrefs.
 577
 578 IMPORTANT: The assumption by users of this routine is that causes blocking
 579 the issue are keyed by uppercase labels and other returned
 580 data is keyed in lower case!
 581
 582 =over 4
 583
 584 =item C<$patron> is a Koha::Patron
 585
 586 =item C<$barcode> is the bar code of the book being issued.
 587
 588 =item C<$duedates> is a DateTime object.
 589
 590 =item C<$inprocess> boolean switch
 591
 592 =item C<$ignore_reserves> boolean switch
 593
 594 =item C<$params> Hashref of additional parameters
 595
 596 Available keys:
 597     override_high_holds - Ignore high holds
 598     onsite_checkout     - Checkout is an onsite checkout that will not leave the library
 599
 600 =back
 601
 602 Returns :
 603
 604 =over 4
 605
 606 =item C<$issuingimpossible> a reference to a hash. It contains reasons why issuing is impossible.
 607 Possible values are :
 608
 609 =back
 610
 611 =head3 INVALID_DATE
 612
 613 sticky due date is invalid
 614
 615 =head3 GNA
 616
 617 borrower gone with no address
 618
 619 =head3 CARD_LOST
 620
 621 borrower declared it's card lost
 622
 623 =head3 DEBARRED
 624
 625 borrower debarred
 626
 627 =head3 UNKNOWN_BARCODE
 628
 629 barcode unknown
 630
 631 =head3 NOT_FOR_LOAN
 632
 633 item is not for loan
 634
 635 =head3 WTHDRAWN
 636
 637 item withdrawn.
 638
 639 =head3 RESTRICTED
 640
 641 item is restricted (set by ??)
 642
 643 C<$needsconfirmation> a reference to a hash. It contains reasons why the loan
 644 could be prevented, but ones that can be overriden by the operator.
 645
 646 Possible values are :
 647
 648 =head3 DEBT
 649
 650 borrower has debts.
 651
 652 =head3 RENEW_ISSUE
 653
 654 renewing, not issuing
 655
 656 =head3 ISSUED_TO_ANOTHER
 657
 658 issued to someone else.
 659
 660 =head3 RESERVED
 661
 662 reserved for someone else.
 663
 664 =head3 INVALID_DATE
 665
 666 sticky due date is invalid or due date in the past
 667
 668 =head3 TOO_MANY
 669
 670 if the borrower borrows to much things
 671
 672 =cut
 673
 674 sub CanBookBeIssued {
 675     my ( $patron, $barcode, $duedate, $inprocess, $ignore_reserves, $params ) = @_;
 676     my %needsconfirmation;    # filled with problems that needs confirmations
 677     my %issuingimpossible;    # filled with problems that causes the issue to be IMPOSSIBLE
 678     my %alerts;               # filled with messages that shouldn't stop issuing, but the librarian should be aware of.
 679     my %messages;             # filled with information messages that should be displayed.
 680
 681     my $onsite_checkout     = $params->{onsite_checkout}     || 0;
 682     my $override_high_holds = $params->{override_high_holds} || 0;
 683
 684     my $item_object = Koha::Items->find({barcode => $barcode });
 685
 686     # MANDATORY CHECKS - unless item exists, nothing else matters
 687     unless ( $item_object ) {
 688         $issuingimpossible{UNKNOWN_BARCODE} = 1;
 689     }
 690     return ( \%issuingimpossible, \%needsconfirmation ) if %issuingimpossible;
 691
 692     my $item_unblessed = $item_object->unblessed; # Transition...
 693     my $issue = $item_object->checkout;
 694     my $biblio = $item_object->biblio;
 695
 696     my $biblioitem = $biblio->biblioitem;
 697     my $effective_itemtype = $item_object->effective_itemtype;
 698     my $dbh             = C4::Context->dbh;
 699     my $patron_unblessed = $patron->unblessed;
 700
 701     my $circ_library = Koha::Libraries->find( _GetCircControlBranch($item_unblessed, $patron_unblessed) );
 702     #
 703     # DUE DATE is OK ? -- should already have checked.
 704     #
 705     if ($duedate && ref $duedate ne 'DateTime') {
 706         $duedate = dt_from_string($duedate);
 707     }
 708     my $now = dt_from_string();
 709     unless ( $duedate ) {
 710         my $issuedate = $now->clone();
 711
 712         $duedate = CalcDateDue( $issuedate, $effective_itemtype, $circ_library->branchcode, $patron_unblessed );
 713
 714         # Offline circ calls AddIssue directly, doesn't run through here
 715         #  So issuingimpossible should be ok.
 716     }
 717
 718     my $fees = Koha::Charges::Fees->new(
 719         {
 720             patron    => $patron,
 721             library   => $circ_library,
 722             item      => $item_object,
 723             to_date   => $duedate,
 724         }
 725     );
 726
 727     if ($duedate) {
 728         my $today = $now->clone();
 729         $today->truncate( to => 'minute');
 730         if (DateTime->compare($duedate,$today) == -1 ) { # duedate cannot be before now
 731             $needsconfirmation{INVALID_DATE} = output_pref($duedate);
 732         }
 733     } else {
 734             $issuingimpossible{INVALID_DATE} = output_pref($duedate);
 735     }
 736
 737     #
 738     # BORROWER STATUS
 739     #
 740     if ( $patron->category->category_type eq 'X' && (  $item_object->barcode  )) {
 741         # stats only borrower -- add entry to statistics table, and return issuingimpossible{STATS} = 1  .
 742         &UpdateStats({
 743                      branch => C4::Context->userenv->{'branch'},
 744                      type => 'localuse',
 745                      itemnumber => $item_object->itemnumber,
 746                      itemtype => $effective_itemtype,
 747                      borrowernumber => $patron->borrowernumber,
 748                      ccode => $item_object->ccode}
 749                     );
 750         ModDateLastSeen( $item_object->itemnumber ); # FIXME Move to Koha::Item
 751         return( { STATS => 1 }, {});
 752     }
 753
 754     if ( $patron->gonenoaddress && $patron->gonenoaddress == 1 ) {
 755         $issuingimpossible{GNA} = 1;
 756     }
 757
 758     if ( $patron->lost && $patron->lost == 1 ) {
 759         $issuingimpossible{CARD_LOST} = 1;
 760     }
 761     if ( $patron->is_debarred ) {
 762         $issuingimpossible{DEBARRED} = 1;
 763     }
 764
 765     if ( $patron->is_expired ) {
 766         $issuingimpossible{EXPIRED} = 1;
 767     }
 768
 769     #
 770     # BORROWER STATUS
 771     #
 772
 773     # DEBTS
 774     my $account = $patron->account;
 775     my $balance = $account->balance;
 776     my $non_issues_charges = $account->non_issues_charges;
 777     my $other_charges = $balance - $non_issues_charges;
 778
 779     my $amountlimit = C4::Context->preference("noissuescharge");
 780     my $allowfineoverride = C4::Context->preference("AllowFineOverride");
 781     my $allfinesneedoverride = C4::Context->preference("AllFinesNeedOverride");
 782
 783     # Check the debt of this patrons guarantees
 784     my $no_issues_charge_guarantees = C4::Context->preference("NoIssuesChargeGuarantees");
 785     $no_issues_charge_guarantees = undef unless looks_like_number( $no_issues_charge_guarantees );
 786     if ( defined $no_issues_charge_guarantees ) {
 787         my @guarantees = map { $_->guarantee } $patron->guarantee_relationships();
 788         my $guarantees_non_issues_charges;
 789         foreach my $g ( @guarantees ) {
 790             $guarantees_non_issues_charges += $g->account->non_issues_charges;
 791         }
 792
 793         if ( $guarantees_non_issues_charges > $no_issues_charge_guarantees && !$inprocess && !$allowfineoverride) {
 794             $issuingimpossible{DEBT_GUARANTEES} = $guarantees_non_issues_charges;
 795         } elsif ( $guarantees_non_issues_charges > $no_issues_charge_guarantees && !$inprocess && $allowfineoverride) {
 796             $needsconfirmation{DEBT_GUARANTEES} = $guarantees_non_issues_charges;
 797         } elsif ( $allfinesneedoverride && $guarantees_non_issues_charges > 0 && $guarantees_non_issues_charges <= $no_issues_charge_guarantees && !$inprocess ) {
 798             $needsconfirmation{DEBT_GUARANTEES} = $guarantees_non_issues_charges;
 799         }
 800     }
 801
 802     if ( C4::Context->preference("IssuingInProcess") ) {
 803         if ( $non_issues_charges > $amountlimit && !$inprocess && !$allowfineoverride) {
 804             $issuingimpossible{DEBT} = $non_issues_charges;
 805         } elsif ( $non_issues_charges > $amountlimit && !$inprocess && $allowfineoverride) {
 806             $needsconfirmation{DEBT} = $non_issues_charges;
 807         } elsif ( $allfinesneedoverride && $non_issues_charges > 0 && $non_issues_charges <= $amountlimit && !$inprocess ) {
 808             $needsconfirmation{DEBT} = $non_issues_charges;
 809         }
 810     }
 811     else {
 812         if ( $non_issues_charges > $amountlimit && $allowfineoverride ) {
 813             $needsconfirmation{DEBT} = $non_issues_charges;
 814         } elsif ( $non_issues_charges > $amountlimit && !$allowfineoverride) {
 815             $issuingimpossible{DEBT} = $non_issues_charges;
 816         } elsif ( $non_issues_charges > 0 && $allfinesneedoverride ) {
 817             $needsconfirmation{DEBT} = $non_issues_charges;
 818         }
 819     }
 820
 821     if ($balance > 0 && $other_charges > 0) {
 822         $alerts{OTHER_CHARGES} = sprintf( "%.2f", $other_charges );
 823     }
 824
 825     $patron = Koha::Patrons->find( $patron->borrowernumber ); # FIXME Refetch just in case, to avoid regressions. But must not be needed
 826     $patron_unblessed = $patron->unblessed;
 827
 828     if ( my $debarred_date = $patron->is_debarred ) {
 829          # patron has accrued fine days or has a restriction. $count is a date
 830         if ($debarred_date eq '9999-12-31') {
 831             $issuingimpossible{USERBLOCKEDNOENDDATE} = $debarred_date;
 832         }
 833         else {
 834             $issuingimpossible{USERBLOCKEDWITHENDDATE} = $debarred_date;
 835         }
 836     } elsif ( my $num_overdues = $patron->has_overdues ) {
 837         ## patron has outstanding overdue loans
 838         if ( C4::Context->preference("OverduesBlockCirc") eq 'block'){
 839             $issuingimpossible{USERBLOCKEDOVERDUE} = $num_overdues;
 840         }
 841         elsif ( C4::Context->preference("OverduesBlockCirc") eq 'confirmation'){
 842             $needsconfirmation{USERBLOCKEDOVERDUE} = $num_overdues;
 843         }
 844     }
 845
 846     #
 847     # CHECK IF BOOK ALREADY ISSUED TO THIS BORROWER
 848     #
 849     if ( $issue && $issue->borrowernumber eq $patron->borrowernumber ){
 850
 851         # Already issued to current borrower.
 852         # If it is an on-site checkout if it can be switched to a normal checkout
 853         # or ask whether the loan should be renewed
 854
 855         if ( $issue->onsite_checkout
 856                 and C4::Context->preference('SwitchOnSiteCheckouts') ) {
 857             $messages{ONSITE_CHECKOUT_WILL_BE_SWITCHED} = 1;
 858         } else {
 859             my ($CanBookBeRenewed,$renewerror) = CanBookBeRenewed(
 860                 $patron->borrowernumber,
 861                 $item_object->itemnumber,
 862             );
 863             if ( $CanBookBeRenewed == 0 ) {    # no more renewals allowed
 864                 if ( $renewerror eq 'onsite_checkout' ) {
 865                     $issuingimpossible{NO_RENEWAL_FOR_ONSITE_CHECKOUTS} = 1;
 866                 }
 867                 else {
 868                     $issuingimpossible{NO_MORE_RENEWALS} = 1;
 869                 }
 870             }
 871             else {
 872                 $needsconfirmation{RENEW_ISSUE} = 1;
 873             }
 874         }
 875     }
 876     elsif ( $issue ) {
 877
 878         # issued to someone else
 879
 880         my $patron = Koha::Patrons->find( $issue->borrowernumber );
 881
 882         my ( $can_be_returned, $message ) = CanBookBeReturned( $item_unblessed, C4::Context->userenv->{branch} );
 883
 884         unless ( $can_be_returned ) {
 885             $issuingimpossible{RETURN_IMPOSSIBLE} = 1;
 886             $issuingimpossible{branch_to_return} = $message;
 887         } else {
 888             if ( C4::Context->preference('AutoReturnCheckedOutItems') ) {
 889                 $alerts{RETURNED_FROM_ANOTHER} = { patron => $patron };
 890             } else {
 891             $needsconfirmation{ISSUED_TO_ANOTHER} = 1;
 892             $needsconfirmation{issued_firstname} = $patron->firstname;
 893             $needsconfirmation{issued_surname} = $patron->surname;
 894             $needsconfirmation{issued_cardnumber} = $patron->cardnumber;
 895             $needsconfirmation{issued_borrowernumber} = $patron->borrowernumber;
 896             }
 897         }
 898     }
 899
 900     # JB34 CHECKS IF BORROWERS DON'T HAVE ISSUE TOO MANY BOOKS
 901     #
 902     my $switch_onsite_checkout = (
 903           C4::Context->preference('SwitchOnSiteCheckouts')
 904       and $issue
 905       and $issue->onsite_checkout
 906       and $issue->borrowernumber == $patron->borrowernumber ? 1 : 0 );
 907     my $toomany = TooMany( $patron_unblessed, $item_object, { onsite_checkout => $onsite_checkout, switch_onsite_checkout => $switch_onsite_checkout, } );
 908     # if TooMany max_allowed returns 0 the user doesn't have permission to check out this book
 909     if ( $toomany && not exists $needsconfirmation{RENEW_ISSUE} ) {
 910         if ( $toomany->{max_allowed} == 0 ) {
 911             $needsconfirmation{PATRON_CANT} = 1;
 912         }
 913         if ( C4::Context->preference("AllowTooManyOverride") ) {
 914             $needsconfirmation{TOO_MANY} = $toomany->{reason};
 915             $needsconfirmation{current_loan_count} = $toomany->{count};
 916             $needsconfirmation{max_loans_allowed} = $toomany->{max_allowed};
 917         } else {
 918             $issuingimpossible{TOO_MANY} = $toomany->{reason};
 919             $issuingimpossible{current_loan_count} = $toomany->{count};
 920             $issuingimpossible{max_loans_allowed} = $toomany->{max_allowed};
 921         }
 922     }
 923
 924     #
 925     # CHECKPREVCHECKOUT: CHECK IF ITEM HAS EVER BEEN LENT TO PATRON
 926     #
 927     $patron = Koha::Patrons->find( $patron->borrowernumber ); # FIXME Refetch just in case, to avoid regressions. But must not be needed
 928     my $wants_check = $patron->wants_check_for_previous_checkout;
 929     $needsconfirmation{PREVISSUE} = 1
 930         if ($wants_check and $patron->do_check_for_previous_checkout($item_unblessed));
 931
 932     #
 933     # ITEM CHECKING
 934     #
 935     if ( $item_object->notforloan )
 936     {
 937         if(!C4::Context->preference("AllowNotForLoanOverride")){
 938             $issuingimpossible{NOT_FOR_LOAN} = 1;
 939             $issuingimpossible{item_notforloan} = $item_object->notforloan;
 940         }else{
 941             $needsconfirmation{NOT_FOR_LOAN_FORCING} = 1;
 942             $needsconfirmation{item_notforloan} = $item_object->notforloan;
 943         }
 944     }
 945     else {
 946         # we have to check itemtypes.notforloan also
 947         if (C4::Context->preference('item-level_itypes')){
 948             # this should probably be a subroutine
 949             my $sth = $dbh->prepare("SELECT notforloan FROM itemtypes WHERE itemtype = ?");
 950             $sth->execute($effective_itemtype);
 951             my $notforloan=$sth->fetchrow_hashref();
 952             if ($notforloan->{'notforloan'}) {
 953                 if (!C4::Context->preference("AllowNotForLoanOverride")) {
 954                     $issuingimpossible{NOT_FOR_LOAN} = 1;
 955                     $issuingimpossible{itemtype_notforloan} = $effective_itemtype;
 956                 } else {
 957                     $needsconfirmation{NOT_FOR_LOAN_FORCING} = 1;
 958                     $needsconfirmation{itemtype_notforloan} = $effective_itemtype;
 959                 }
 960             }
 961         }
 962         else {
 963             my $itemtype = Koha::ItemTypes->find($biblioitem->itemtype);
 964             if ( $itemtype && defined $itemtype->notforloan && $itemtype->notforloan == 1){
 965                 if (!C4::Context->preference("AllowNotForLoanOverride")) {
 966                     $issuingimpossible{NOT_FOR_LOAN} = 1;
 967                     $issuingimpossible{itemtype_notforloan} = $effective_itemtype;
 968                 } else {
 969                     $needsconfirmation{NOT_FOR_LOAN_FORCING} = 1;
 970                     $needsconfirmation{itemtype_notforloan} = $effective_itemtype;
 971                 }
 972             }
 973         }
 974     }
 975     if ( $item_object->withdrawn && $item_object->withdrawn > 0 )
 976     {
 977         $issuingimpossible{WTHDRAWN} = 1;
 978     }
 979     if (   $item_object->restricted
 980         && $item_object->restricted == 1 )
 981     {
 982         $issuingimpossible{RESTRICTED} = 1;
 983     }
 984     if ( $item_object->itemlost && C4::Context->preference("IssueLostItem") ne 'nothing' ) {
 985         my $av = Koha::AuthorisedValues->search({ category => 'LOST', authorised_value => $item_object->itemlost });
 986         my $code = $av->count ? $av->next->lib : '';
 987         $needsconfirmation{ITEM_LOST} = $code if ( C4::Context->preference("IssueLostItem") eq 'confirm' );
 988         $alerts{ITEM_LOST} = $code if ( C4::Context->preference("IssueLostItem") eq 'alert' );
 989     }
 990     if ( C4::Context->preference("IndependentBranches") ) {
 991         my $userenv = C4::Context->userenv;
 992         unless ( C4::Context->IsSuperLibrarian() ) {
 993             my $HomeOrHoldingBranch = C4::Context->preference("HomeOrHoldingBranch");
 994             if ( $item_object->$HomeOrHoldingBranch ne $userenv->{branch} ){
 995                 $issuingimpossible{ITEMNOTSAMEBRANCH} = 1;
 996                 $issuingimpossible{'itemhomebranch'} = $item_object->$HomeOrHoldingBranch;
 997             }
 998             $needsconfirmation{BORRNOTSAMEBRANCH} = $patron->branchcode
 999               if ( $patron->branchcode ne $userenv->{branch} );
1000         }
1001     }
1002
1003     #
1004     # CHECK IF THERE IS RENTAL CHARGES. RENTAL MUST BE CONFIRMED BY THE BORROWER
1005     #
1006     my $rentalConfirmation = C4::Context->preference("RentalFeesCheckoutConfirmation");
1007     if ($rentalConfirmation) {
1008         my ($rentalCharge) = GetIssuingCharges( $item_object->itemnumber, $patron->borrowernumber );
1009
1010         my $itemtype_object = Koha::ItemTypes->find( $item_object->effective_itemtype );
1011         if ($itemtype_object) {
1012             my $accumulate_charge = $fees->accumulate_rentalcharge();
1013             if ( $accumulate_charge > 0 ) {
1014                 $rentalCharge += $accumulate_charge;
1015             }
1016         }
1017
1018         if ( $rentalCharge > 0 ) {
1019             $needsconfirmation{RENTALCHARGE} = $rentalCharge;
1020         }
1021     }
1022
1023     unless ( $ignore_reserves ) {
1024         # See if the item is on reserve.
1025         my ( $restype, $res ) = C4::Reserves::CheckReserves( $item_object->itemnumber );
1026         if ($restype) {
1027             my $resbor = $res->{'borrowernumber'};
1028             if ( $resbor ne $patron->borrowernumber ) {
1029                 my $patron = Koha::Patrons->find( $resbor );
1030                 if ( $restype eq "Waiting" )
1031                 {
1032                     # The item is on reserve and waiting, but has been
1033                     # reserved by some other patron.
1034                     $needsconfirmation{RESERVE_WAITING} = 1;
1035                     $needsconfirmation{'resfirstname'} = $patron->firstname;
1036                     $needsconfirmation{'ressurname'} = $patron->surname;
1037                     $needsconfirmation{'rescardnumber'} = $patron->cardnumber;
1038                     $needsconfirmation{'resborrowernumber'} = $patron->borrowernumber;
1039                     $needsconfirmation{'resbranchcode'} = $res->{branchcode};
1040                     $needsconfirmation{'reswaitingdate'} = $res->{'waitingdate'};
1041                     $needsconfirmation{'reserve_id'} = $res->{reserve_id};
1042                 }
1043                 elsif ( $restype eq "Reserved" ) {
1044                     # The item is on reserve for someone else.
1045                     $needsconfirmation{RESERVED} = 1;
1046                     $needsconfirmation{'resfirstname'} = $patron->firstname;
1047                     $needsconfirmation{'ressurname'} = $patron->surname;
1048                     $needsconfirmation{'rescardnumber'} = $patron->cardnumber;
1049                     $needsconfirmation{'resborrowernumber'} = $patron->borrowernumber;
1050                     $needsconfirmation{'resbranchcode'} = $patron->branchcode;
1051                     $needsconfirmation{'resreservedate'} = $res->{reservedate};
1052                     $needsconfirmation{'reserve_id'} = $res->{reserve_id};
1053                 }
1054             }
1055         }
1056     }
1057
1058     ## CHECK AGE RESTRICTION
1059     my $agerestriction  = $biblioitem->agerestriction;
1060     my ($restriction_age, $daysToAgeRestriction) = GetAgeRestriction( $agerestriction, $patron->unblessed );
1061     if ( $daysToAgeRestriction && $daysToAgeRestriction > 0 ) {
1062         if ( C4::Context->preference('AgeRestrictionOverride') ) {
1063             $needsconfirmation{AGE_RESTRICTION} = "$agerestriction";
1064         }
1065         else {
1066             $issuingimpossible{AGE_RESTRICTION} = "$agerestriction";
1067         }
1068     }
1069
1070     ## check for high holds decreasing loan period
1071     if ( C4::Context->preference('decreaseLoanHighHolds') ) {
1072         my $check = checkHighHolds( $item_unblessed, $patron_unblessed );
1073
1074         if ( $check->{exceeded} ) {
1075             if ($override_high_holds) {
1076                 $alerts{HIGHHOLDS} = {
1077                     num_holds  => $check->{outstanding},
1078                     duration   => $check->{duration},
1079                     returndate => output_pref( { dt => dt_from_string($check->{due_date}), dateformat => 'iso', timeformat => '24hr' }),
1080                 };
1081             }
1082             else {
1083                 $needsconfirmation{HIGHHOLDS} = {
1084                     num_holds  => $check->{outstanding},
1085                     duration   => $check->{duration},
1086                     returndate => output_pref( { dt => dt_from_string($check->{due_date}), dateformat => 'iso', timeformat => '24hr' }),
1087                 };
1088             }
1089         }
1090     }
1091
1092     if (
1093         !C4::Context->preference('AllowMultipleIssuesOnABiblio') &&
1094         # don't do the multiple loans per bib check if we've
1095         # already determined that we've got a loan on the same item
1096         !$issuingimpossible{NO_MORE_RENEWALS} &&
1097         !$needsconfirmation{RENEW_ISSUE}
1098     ) {
1099         # Check if borrower has already issued an item from the same biblio
1100         # Only if it's not a subscription
1101         my $biblionumber = $item_object->biblionumber;
1102         require C4::Serials;
1103         my $is_a_subscription = C4::Serials::CountSubscriptionFromBiblionumber($biblionumber);
1104         unless ($is_a_subscription) {
1105             # FIXME Should be $patron->checkouts($args);
1106             my $checkouts = Koha::Checkouts->search(
1107                 {
1108                     borrowernumber => $patron->borrowernumber,
1109                     biblionumber   => $biblionumber,
1110                 },
1111                 {
1112                     join => 'item',
1113                 }
1114             );
1115             # if we get here, we don't already have a loan on this item,
1116             # so if there are any loans on this bib, ask for confirmation
1117             if ( $checkouts->count ) {
1118                 $needsconfirmation{BIBLIO_ALREADY_ISSUED} = 1;
1119             }
1120         }
1121     }
1122
1123     return ( \%issuingimpossible, \%needsconfirmation, \%alerts, \%messages, );
1124 }
1125
1126 =head2 CanBookBeReturned
1127
1128   ($returnallowed, $message) = CanBookBeReturned($item, $branch)
1129
1130 Check whether the item can be returned to the provided branch
1131
1132 =over 4
1133
1134 =item C<$item> is a hash of item information as returned Koha::Items->find->unblessed (Temporary, should be a Koha::Item instead)
1135
1136 =item C<$branch> is the branchcode where the return is taking place
1137
1138 =back
1139
1140 Returns:
1141
1142 =over 4
1143
1144 =item C<$returnallowed> is 0 or 1, corresponding to whether the return is allowed (1) or not (0)
1145
1146 =item C<$message> is the branchcode where the item SHOULD be returned, if the return is not allowed
1147
1148 =back
1149
1150 =cut
1151
1152 sub CanBookBeReturned {
1153   my ($item, $branch) = @_;
1154   my $allowreturntobranch = C4::Context->preference("AllowReturnToBranch") || 'anywhere';
1155
1156   # assume return is allowed to start
1157   my $allowed = 1;
1158   my $message;
1159
1160   # identify all cases where return is forbidden
1161   if ($allowreturntobranch eq 'homebranch' && $branch ne $item->{'homebranch'}) {
1162      $allowed = 0;
1163      $message = $item->{'homebranch'};
1164   } elsif ($allowreturntobranch eq 'holdingbranch' && $branch ne $item->{'holdingbranch'}) {
1165      $allowed = 0;
1166      $message = $item->{'holdingbranch'};
1167   } elsif ($allowreturntobranch eq 'homeorholdingbranch' && $branch ne $item->{'homebranch'} && $branch ne $item->{'holdingbranch'}) {
1168      $allowed = 0;
1169      $message = $item->{'homebranch'}; # FIXME: choice of homebranch is arbitrary
1170   }
1171
1172   return ($allowed, $message);
1173 }
1174
1175 =head2 CheckHighHolds
1176
1177     used when syspref decreaseLoanHighHolds is active. Returns 1 or 0 to define whether the minimum value held in
1178     decreaseLoanHighHoldsValue is exceeded, the total number of outstanding holds, the number of days the loan
1179     has been decreased to (held in syspref decreaseLoanHighHoldsValue), and the new due date
1180
1181 =cut
1182
1183 sub checkHighHolds {
1184     my ( $item, $borrower ) = @_;
1185     my $branchcode = _GetCircControlBranch( $item, $borrower );
1186     my $item_object = Koha::Items->find( $item->{itemnumber} );
1187
1188     my $return_data = {
1189         exceeded    => 0,
1190         outstanding => 0,
1191         duration    => 0,
1192         due_date    => undef,
1193     };
1194
1195     my $holds = Koha::Holds->search( { biblionumber => $item->{'biblionumber'} } );
1196
1197     if ( $holds->count() ) {
1198         $return_data->{outstanding} = $holds->count();
1199
1200         my $decreaseLoanHighHoldsControl        = C4::Context->preference('decreaseLoanHighHoldsControl');
1201         my $decreaseLoanHighHoldsValue          = C4::Context->preference('decreaseLoanHighHoldsValue');
1202         my $decreaseLoanHighHoldsIgnoreStatuses = C4::Context->preference('decreaseLoanHighHoldsIgnoreStatuses');
1203
1204         my @decreaseLoanHighHoldsIgnoreStatuses = split( /,/, $decreaseLoanHighHoldsIgnoreStatuses );
1205
1206         if ( $decreaseLoanHighHoldsControl eq 'static' ) {
1207
1208             # static means just more than a given number of holds on the record
1209
1210             # If the number of holds is less than the threshold, we can stop here
1211             if ( $holds->count() < $decreaseLoanHighHoldsValue ) {
1212                 return $return_data;
1213             }
1214         }
1215         elsif ( $decreaseLoanHighHoldsControl eq 'dynamic' ) {
1216
1217             # dynamic means X more than the number of holdable items on the record
1218
1219             # let's get the items
1220             my @items = $holds->next()->biblio()->items()->as_list;
1221
1222             # Remove any items with status defined to be ignored even if the would not make item unholdable
1223             foreach my $status (@decreaseLoanHighHoldsIgnoreStatuses) {
1224                 @items = grep { !$_->$status } @items;
1225             }
1226
1227             # Remove any items that are not holdable for this patron
1228             @items = grep { CanItemBeReserved( $borrower->{borrowernumber}, $_->itemnumber, undef, { ignore_found_holds => 1 } )->{status} eq 'OK' } @items;
1229
1230             my $items_count = scalar @items;
1231
1232             my $threshold = $items_count + $decreaseLoanHighHoldsValue;
1233
1234             # If the number of holds is less than the count of items we have
1235             # plus the number of holds allowed above that count, we can stop here
1236             if ( $holds->count() <= $threshold ) {
1237                 return $return_data;
1238             }
1239         }
1240
1241         my $issuedate = dt_from_string();
1242
1243         my $calendar = Koha::Calendar->new( branchcode => $branchcode );
1244
1245         my $itype = $item_object->effective_itemtype;
1246         my $orig_due = C4::Circulation::CalcDateDue( $issuedate, $itype, $branchcode, $borrower );
1247
1248         my $decreaseLoanHighHoldsDuration = C4::Context->preference('decreaseLoanHighHoldsDuration');
1249
1250         my $reduced_datedue = $calendar->addDate( $issuedate, $decreaseLoanHighHoldsDuration );
1251         $reduced_datedue->set_hour($orig_due->hour);
1252         $reduced_datedue->set_minute($orig_due->minute);
1253         $reduced_datedue->truncate( to => 'minute' );
1254
1255         if ( DateTime->compare( $reduced_datedue, $orig_due ) == -1 ) {
1256             $return_data->{exceeded} = 1;
1257             $return_data->{duration} = $decreaseLoanHighHoldsDuration;
1258             $return_data->{due_date} = $reduced_datedue;
1259         }
1260     }
1261
1262     return $return_data;
1263 }
1264
1265 =head2 AddIssue
1266
1267   &AddIssue($borrower, $barcode, [$datedue], [$cancelreserve], [$issuedate])
1268
1269 Issue a book. Does no check, they are done in CanBookBeIssued. If we reach this sub, it means the user confirmed if needed.
1270
1271 =over 4
1272
1273 =item C<$borrower> is a hash with borrower informations (from Koha::Patron->unblessed).
1274
1275 =item C<$barcode> is the barcode of the item being issued.
1276
1277 =item C<$datedue> is a DateTime object for the max date of return, i.e. the date due (optional).
1278 Calculated if empty.
1279
1280 =item C<$cancelreserve> is 1 to override and cancel any pending reserves for the item (optional).
1281
1282 =item C<$issuedate> is the date to issue the item in iso (YYYY-MM-DD) format (optional).
1283 Defaults to today.  Unlike C<$datedue>, NOT a DateTime object, unfortunately.
1284
1285 AddIssue does the following things :
1286
1287   - step 01: check that there is a borrowernumber & a barcode provided
1288   - check for RENEWAL (book issued & being issued to the same patron)
1289       - renewal YES = Calculate Charge & renew
1290       - renewal NO  =
1291           * BOOK ACTUALLY ISSUED ? do a return if book is actually issued (but to someone else)
1292           * RESERVE PLACED ?
1293               - fill reserve if reserve to this patron
1294               - cancel reserve or not, otherwise
1295           * TRANSFERT PENDING ?
1296               - complete the transfert
1297           * ISSUE THE BOOK
1298
1299 =back
1300
1301 =cut
1302
1303 sub AddIssue {
1304     my ( $borrower, $barcode, $datedue, $cancelreserve, $issuedate, $sipmode, $params ) = @_;
1305
1306     my $onsite_checkout = $params && $params->{onsite_checkout} ? 1 : 0;
1307     my $switch_onsite_checkout = $params && $params->{switch_onsite_checkout};
1308     my $auto_renew = $params && $params->{auto_renew};
1309     my $dbh          = C4::Context->dbh;
1310     my $barcodecheck = CheckValidBarcode($barcode);
1311
1312     my $issue;
1313
1314     if ( $datedue && ref $datedue ne 'DateTime' ) {
1315         $datedue = dt_from_string($datedue);
1316     }
1317
1318     # $issuedate defaults to today.
1319     if ( !defined $issuedate ) {
1320         $issuedate = dt_from_string();
1321     }
1322     else {
1323         if ( ref $issuedate ne 'DateTime' ) {
1324             $issuedate = dt_from_string($issuedate);
1325
1326         }
1327     }
1328
1329     # Stop here if the patron or barcode doesn't exist
1330     if ( $borrower && $barcode && $barcodecheck ) {
1331         # find which item we issue
1332         my $item_object = Koha::Items->find({ barcode => $barcode })
1333           or return;    # if we don't get an Item, abort.
1334         my $item_unblessed = $item_object->unblessed;
1335
1336         my $branchcode = _GetCircControlBranch( $item_unblessed, $borrower );
1337
1338         # get actual issuing if there is one
1339         my $actualissue = $item_object->checkout;
1340
1341         # check if we just renew the issue.
1342         if ( $actualissue and $actualissue->borrowernumber eq $borrower->{'borrowernumber'}
1343                 and not $switch_onsite_checkout ) {
1344             $datedue = AddRenewal(
1345                 $borrower->{'borrowernumber'},
1346                 $item_object->itemnumber,
1347                 $branchcode,
1348                 $datedue,
1349                 $issuedate,    # here interpreted as the renewal date
1350             );
1351         }
1352         else {
1353             unless ($datedue) {
1354                 my $itype = $item_object->effective_itemtype;
1355                 $datedue = CalcDateDue( $issuedate, $itype, $branchcode, $borrower );
1356
1357             }
1358             $datedue->truncate( to => 'minute' );
1359
1360             my $patron = Koha::Patrons->find( $borrower );
1361             my $library = Koha::Libraries->find( $branchcode );
1362             my $fees = Koha::Charges::Fees->new(
1363                 {
1364                     patron    => $patron,
1365                     library   => $library,
1366                     item      => $item_object,
1367                     to_date   => $datedue,
1368                 }
1369             );
1370
1371             # it's NOT a renewal
1372             if ( $actualissue and not $switch_onsite_checkout ) {
1373                 # This book is currently on loan, but not to the person
1374                 # who wants to borrow it now. mark it returned before issuing to the new borrower
1375                 my ( $allowed, $message ) = CanBookBeReturned( $item_unblessed, C4::Context->userenv->{branch} );
1376                 return unless $allowed;
1377                 AddReturn( $item_object->barcode, C4::Context->userenv->{'branch'} );
1378             }
1379
1380             C4::Reserves::MoveReserve( $item_object->itemnumber, $borrower->{'borrowernumber'}, $cancelreserve );
1381
1382             # Starting process for transfer job (checking transfert and validate it if we have one)
1383             my ($datesent) = GetTransfers( $item_object->itemnumber );
1384             if ($datesent) {
1385                 # updating line of branchtranfert to finish it, and changing the to branch value, implement a comment for visibility of this case (maybe for stats ....)
1386                 my $sth = $dbh->prepare(
1387                     "UPDATE branchtransfers
1388                         SET datearrived = now(),
1389                         tobranch = ?,
1390                         comments = 'Forced branchtransfer'
1391                     WHERE itemnumber= ? AND datearrived IS NULL"
1392                 );
1393                 $sth->execute( C4::Context->userenv->{'branch'},
1394                     $item_object->itemnumber );
1395             }
1396
1397             # If automatic renewal wasn't selected while issuing, set the value according to the issuing rule.
1398             unless ($auto_renew) {
1399                 my $rule = Koha::CirculationRules->get_effective_rule(
1400                     {
1401                         categorycode => $borrower->{categorycode},
1402                         itemtype     => $item_object->effective_itemtype,
1403                         branchcode   => $branchcode,
1404                         rule_name    => 'auto_renew'
1405                     }
1406                 );
1407
1408                 $auto_renew = $rule->rule_value if $rule;
1409             }
1410
1411             my $issue_attributes = {
1412                 borrowernumber  => $borrower->{'borrowernumber'},
1413                 issuedate       => $issuedate->strftime('%Y-%m-%d %H:%M:%S'),
1414                 date_due        => $datedue->strftime('%Y-%m-%d %H:%M:%S'),
1415                 branchcode      => C4::Context->userenv->{'branch'},
1416                 onsite_checkout => $onsite_checkout,
1417                 auto_renew      => $auto_renew ? 1 : 0,
1418             };
1419
1420             # In the case that the borrower has an on-site checkout
1421             # and SwitchOnSiteCheckouts is enabled this converts it to a regular checkout
1422             $issue = Koha::Checkouts->find( { itemnumber => $item_object->itemnumber } );
1423             if ($issue) {
1424                 $issue->set($issue_attributes)->store;
1425             }
1426             else {
1427                 $issue = Koha::Checkout->new(
1428                     {
1429                         itemnumber => $item_object->itemnumber,
1430                         %$issue_attributes,
1431                     }
1432                 )->store;
1433             }
1434             if ( $item_object->location && $item_object->location eq 'CART'
1435                 && ( !$item_object->permanent_location || $item_object->permanent_location ne 'CART' ) ) {
1436             ## Item was moved to cart via UpdateItemLocationOnCheckin, anything issued should be taken off the cart.
1437                 CartToShelf( $item_object->itemnumber );
1438             }
1439
1440             if ( C4::Context->preference('UpdateTotalIssuesOnCirc') ) {
1441                 UpdateTotalIssues( $item_object->biblionumber, 1 );
1442             }
1443
1444             ## If item was lost, it has now been found, reverse any list item charges if necessary.
1445             if ( $item_object->itemlost ) {
1446                 if (
1447                     Koha::RefundLostItemFeeRules->should_refund(
1448                         {
1449                             current_branch      => C4::Context->userenv->{branch},
1450                             item_home_branch    => $item_object->homebranch,
1451                             item_holding_branch => $item_object->holdingbranch,
1452                         }
1453                     )
1454                   )
1455                 {
1456                     _FixAccountForLostAndFound( $item_object->itemnumber, undef,
1457                         $item_object->barcode );
1458                 }
1459             }
1460
1461             $item_object->issues( ( $item_object->issues || 0 ) + 1);
1462             $item_object->holdingbranch(C4::Context->userenv->{'branch'});
1463             $item_object->itemlost(0);
1464             $item_object->onloan($datedue->ymd());
1465             $item_object->datelastborrowed( dt_from_string()->ymd() );
1466             $item_object->datelastseen( dt_from_string()->ymd() );
1467             $item_object->store({log_action => 0});
1468
1469             # If it costs to borrow this book, charge it to the patron's account.
1470             my ( $charge, $itemtype ) = GetIssuingCharges( $item_object->itemnumber, $borrower->{'borrowernumber'} );
1471             if ( $charge && $charge > 0 ) {
1472                 AddIssuingCharge( $issue, $charge, 'RENT' );
1473             }
1474
1475             my $itemtype_object = Koha::ItemTypes->find( $item_object->effective_itemtype );
1476             if ( $itemtype_object ) {
1477                 my $accumulate_charge = $fees->accumulate_rentalcharge();
1478                 if ( $accumulate_charge > 0 ) {
1479                     AddIssuingCharge( $issue, $accumulate_charge, 'RENT_DAILY' );
1480                     $charge += $accumulate_charge;
1481                     $item_unblessed->{charge} = $charge;
1482                 }
1483             }
1484
1485             # Record the fact that this book was issued.
1486             &UpdateStats(
1487                 {
1488                     branch => C4::Context->userenv->{'branch'},
1489                     type => ( $onsite_checkout ? 'onsite_checkout' : 'issue' ),
1490                     amount         => $charge,
1491                     other          => ( $sipmode ? "SIP-$sipmode" : '' ),
1492                     itemnumber     => $item_object->itemnumber,
1493                     itemtype       => $item_object->effective_itemtype,
1494                     location       => $item_object->location,
1495                     borrowernumber => $borrower->{'borrowernumber'},
1496                     ccode          => $item_object->ccode,
1497                 }
1498             );
1499
1500             # Send a checkout slip.
1501             my $circulation_alert = 'C4::ItemCirculationAlertPreference';
1502             my %conditions        = (
1503                 branchcode   => $branchcode,
1504                 categorycode => $borrower->{categorycode},
1505                 item_type    => $item_object->effective_itemtype,
1506                 notification => 'CHECKOUT',
1507             );
1508             if ( $circulation_alert->is_enabled_for( \%conditions ) ) {
1509                 SendCirculationAlert(
1510                     {
1511                         type     => 'CHECKOUT',
1512                         item     => $item_object->unblessed,
1513                         borrower => $borrower,
1514                         branch   => $branchcode,
1515                     }
1516                 );
1517             }
1518             logaction(
1519                 "CIRCULATION", "ISSUE",
1520                 $borrower->{'borrowernumber'},
1521                 $item_object->itemnumber,
1522             ) if C4::Context->preference("IssueLog");
1523         }
1524     }
1525     return $issue;
1526 }
1527
1528 =head2 GetLoanLength
1529
1530   my $loanlength = &GetLoanLength($borrowertype,$itemtype,branchcode)
1531
1532 Get loan length for an itemtype, a borrower type and a branch
1533
1534 =cut
1535
1536 sub GetLoanLength {
1537     my ( $categorycode, $itemtype, $branchcode ) = @_;
1538
1539     # Set search precedences
1540     my @params = (
1541         {
1542             categorycode => $categorycode,
1543             itemtype     => $itemtype,
1544             branchcode   => $branchcode,
1545         },
1546         {
1547             categorycode => $categorycode,
1548             itemtype     => undef,
1549             branchcode   => $branchcode,
1550         },
1551         {
1552             categorycode => undef,
1553             itemtype     => $itemtype,
1554             branchcode   => $branchcode,
1555         },
1556         {
1557             categorycode => undef,
1558             itemtype     => undef,
1559             branchcode   => $branchcode,
1560         },
1561         {
1562             categorycode => $categorycode,
1563             itemtype     => $itemtype,
1564             branchcode   => undef,
1565         },
1566         {
1567             categorycode => $categorycode,
1568             itemtype     => undef,
1569             branchcode   => undef,
1570         },
1571         {
1572             categorycode => undef,
1573             itemtype     => $itemtype,
1574             branchcode   => undef,
1575         },
1576         {
1577             categorycode => undef,
1578             itemtype     => undef,
1579             branchcode   => undef,
1580         },
1581     );
1582
1583     # Initialize default values
1584     my $rules = {
1585         issuelength   => 0,
1586         renewalperiod => 0,
1587         lengthunit    => 'days',
1588     };
1589
1590     # Search for rules!
1591     foreach my $rule_name (qw( issuelength renewalperiod lengthunit )) {
1592         foreach my $params (@params) {
1593             my $rule = Koha::CirculationRules->search(
1594                 {
1595                     rule_name => $rule_name,
1596                     %$params,
1597                 }
1598             )->next();
1599
1600             if ($rule) {
1601                 $rules->{$rule_name} = $rule->rule_value;
1602                 last;
1603             }
1604         }
1605     }
1606
1607     return $rules;
1608 }
1609
1610
1611 =head2 GetHardDueDate
1612
1613   my ($hardduedate,$hardduedatecompare) = &GetHardDueDate($borrowertype,$itemtype,branchcode)
1614
1615 Get the Hard Due Date and it's comparison for an itemtype, a borrower type and a branch
1616
1617 =cut
1618
1619 sub GetHardDueDate {
1620     my ( $borrowertype, $itemtype, $branchcode ) = @_;
1621
1622     my $rules = Koha::CirculationRules->get_effective_rules(
1623         {
1624             categorycode => $borrowertype,
1625             itemtype     => $itemtype,
1626             branchcode   => $branchcode,
1627             rules        => [ 'hardduedate', 'hardduedatecompare' ],
1628         }
1629     );
1630
1631     if ( defined( $rules->{hardduedate} ) ) {
1632         if ( $rules->{hardduedate} ) {
1633             return ( dt_from_string( $rules->{hardduedate}, 'iso' ), $rules->{hardduedatecompare} );
1634         }
1635         else {
1636             return ( undef, undef );
1637         }
1638     }
1639 }
1640
1641 =head2 GetBranchBorrowerCircRule
1642
1643   my $branch_cat_rule = GetBranchBorrowerCircRule($branchcode, $categorycode);
1644
1645 Retrieves circulation rule attributes that apply to the given
1646 branch and patron category, regardless of item type.
1647 The return value is a hashref containing the following key:
1648
1649 patron_maxissueqty - maximum number of loans that a
1650 patron of the given category can have at the given
1651 branch.  If the value is undef, no limit.
1652
1653 patron_maxonsiteissueqty - maximum of on-site checkouts that a
1654 patron of the given category can have at the given
1655 branch.  If the value is undef, no limit.
1656
1657 This will check for different branch/category combinations in the following order:
1658 branch and category
1659 branch only
1660 category only
1661 default branch and category
1662
1663 If no rule has been found in the database, it will default to
1664 the buillt in rule:
1665
1666 patron_maxissueqty - undef
1667 patron_maxonsiteissueqty - undef
1668
1669 C<$branchcode> and C<$categorycode> should contain the
1670 literal branch code and patron category code, respectively - no
1671 wildcards.
1672
1673 =cut
1674
1675 sub GetBranchBorrowerCircRule {
1676     my ( $branchcode, $categorycode ) = @_;
1677
1678     # Initialize default values
1679     my $rules = {
1680         patron_maxissueqty       => undef,
1681         patron_maxonsiteissueqty => undef,
1682     };
1683
1684     # Search for rules!
1685     foreach my $rule_name (qw( patron_maxissueqty patron_maxonsiteissueqty )) {
1686         my $rule = Koha::CirculationRules->get_effective_rule(
1687             {
1688                 categorycode => $categorycode,
1689                 itemtype     => undef,
1690                 branchcode   => $branchcode,
1691                 rule_name    => $rule_name,
1692             }
1693         );
1694
1695         $rules->{$rule_name} = $rule->rule_value if defined $rule;
1696     }
1697
1698     return $rules;
1699 }
1700
1701 =head2 GetBranchItemRule
1702
1703   my $branch_item_rule = GetBranchItemRule($branchcode, $itemtype);
1704
1705 Retrieves circulation rule attributes that apply to the given
1706 branch and item type, regardless of patron category.
1707
1708 The return value is a hashref containing the following keys:
1709
1710 holdallowed => Hold policy for this branch and itemtype. Possible values:
1711   0: No holds allowed.
1712   1: Holds allowed only by patrons that have the same homebranch as the item.
1713   2: Holds allowed from any patron.
1714
1715 returnbranch => branch to which to return item.  Possible values:
1716   noreturn: do not return, let item remain where checked in (floating collections)
1717   homebranch: return to item's home branch
1718   holdingbranch: return to issuer branch
1719
1720 This searches branchitemrules in the following order:
1721
1722   * Same branchcode and itemtype
1723   * Same branchcode, itemtype '*'
1724   * branchcode '*', same itemtype
1725   * branchcode and itemtype '*'
1726
1727 Neither C<$branchcode> nor C<$itemtype> should be '*'.
1728
1729 =cut
1730
1731 sub GetBranchItemRule {
1732     my ( $branchcode, $itemtype ) = @_;
1733
1734     # Search for rules!
1735     my $holdallowed_rule = Koha::CirculationRules->get_effective_rule(
1736         {
1737             branchcode => $branchcode,
1738             itemtype => $itemtype,
1739             rule_name => 'holdallowed',
1740         }
1741     );
1742     my $hold_fulfillment_policy_rule = Koha::CirculationRules->get_effective_rule(
1743         {
1744             branchcode => $branchcode,
1745             itemtype => $itemtype,
1746             rule_name => 'hold_fulfillment_policy',
1747         }
1748     );
1749     my $returnbranch_rule = Koha::CirculationRules->get_effective_rule(
1750         {
1751             branchcode => $branchcode,
1752             itemtype => $itemtype,
1753             rule_name => 'returnbranch',
1754         }
1755     );
1756
1757     # built-in default circulation rule
1758     my $rules;
1759     $rules->{holdallowed} = defined $holdallowed_rule
1760         ? $holdallowed_rule->rule_value
1761         : 2;
1762     $rules->{hold_fulfillment_policy} = defined $hold_fulfillment_policy_rule
1763         ? $hold_fulfillment_policy_rule->rule_value
1764         : 'any';
1765     $rules->{returnbranch} = defined $returnbranch_rule
1766         ? $returnbranch_rule->rule_value
1767         : 'homebranch';
1768
1769     return $rules;
1770 }
1771
1772 =head2 AddReturn
1773
1774   ($doreturn, $messages, $iteminformation, $borrower) =
1775       &AddReturn( $barcode, $branch [,$exemptfine] [,$returndate] );
1776
1777 Returns a book.
1778
1779 =over 4
1780
1781 =item C<$barcode> is the bar code of the book being returned.
1782
1783 =item C<$branch> is the code of the branch where the book is being returned.
1784
1785 =item C<$exemptfine> indicates that overdue charges for the item will be
1786 removed. Optional.
1787
1788 =item C<$return_date> allows the default return date to be overridden
1789 by the given return date. Optional.
1790
1791 =back
1792
1793 C<&AddReturn> returns a list of four items:
1794
1795 C<$doreturn> is true iff the return succeeded.
1796
1797 C<$messages> is a reference-to-hash giving feedback on the operation.
1798 The keys of the hash are:
1799
1800 =over 4
1801
1802 =item C<BadBarcode>
1803
1804 No item with this barcode exists. The value is C<$barcode>.
1805
1806 =item C<NotIssued>
1807
1808 The book is not currently on loan. The value is C<$barcode>.
1809
1810 =item C<withdrawn>
1811
1812 This book has been withdrawn/cancelled. The value should be ignored.
1813
1814 =item C<Wrongbranch>
1815
1816 This book has was returned to the wrong branch.  The value is a hashref
1817 so that C<$messages->{Wrongbranch}->{Wrongbranch}> and C<$messages->{Wrongbranch}->{Rightbranch}>
1818 contain the branchcode of the incorrect and correct return library, respectively.
1819
1820 =item C<ResFound>
1821
1822 The item was reserved. The value is a reference-to-hash whose keys are
1823 fields from the reserves table of the Koha database, and
1824 C<biblioitemnumber>. It also has the key C<ResFound>, whose value is
1825 either C<Waiting>, C<Reserved>, or 0.
1826
1827 =item C<WasReturned>
1828
1829 Value 1 if return is successful.
1830
1831 =item C<NeedsTransfer>
1832
1833 If AutomaticItemReturn is disabled, return branch is given as value of NeedsTransfer.
1834
1835 =back
1836
1837 C<$iteminformation> is a reference-to-hash, giving information about the
1838 returned item from the issues table.
1839
1840 C<$borrower> is a reference-to-hash, giving information about the
1841 patron who last borrowed the book.
1842
1843 =cut
1844
1845 sub AddReturn {
1846     my ( $barcode, $branch, $exemptfine, $return_date ) = @_;
1847
1848     if ($branch and not Koha::Libraries->find($branch)) {
1849         warn "AddReturn error: branch '$branch' not found.  Reverting to " . C4::Context->userenv->{'branch'};
1850         undef $branch;
1851     }
1852     $branch = C4::Context->userenv->{'branch'} unless $branch;  # we trust userenv to be a safe fallback/default
1853     my $return_date_specified = !!$return_date;
1854     $return_date //= dt_from_string();
1855     my $messages;
1856     my $patron;
1857     my $doreturn       = 1;
1858     my $validTransfer = 1;
1859     my $stat_type = 'return';
1860
1861     # get information on item
1862     my $item = Koha::Items->find({ barcode => $barcode });
1863     unless ($item) {
1864         return ( 0, { BadBarcode => $barcode } );    # no barcode means no item or borrower.  bail out.
1865     }
1866
1867     my $itemnumber = $item->itemnumber;
1868     my $itemtype = $item->effective_itemtype;
1869
1870     my $issue  = $item->checkout;
1871     if ( $issue ) {
1872         $patron = $issue->patron
1873             or die "Data inconsistency: barcode $barcode (itemnumber:$itemnumber) claims to be issued to non-existent borrowernumber '" . $issue->borrowernumber . "'\n"
1874                 . Dumper($issue->unblessed) . "\n";
1875     } else {
1876         $messages->{'NotIssued'} = $barcode;
1877         $item->onloan(undef)->store({skip_record_index=>1}) if defined $item->onloan;
1878
1879         # even though item is not on loan, it may still be transferred;  therefore, get current branch info
1880         $doreturn = 0;
1881         # No issue, no borrowernumber.  ONLY if $doreturn, *might* you have a $borrower later.
1882         # Record this as a local use, instead of a return, if the RecordLocalUseOnReturn is on
1883         if (C4::Context->preference("RecordLocalUseOnReturn")) {
1884            $messages->{'LocalUse'} = 1;
1885            $stat_type = 'localuse';
1886         }
1887     }
1888
1889         # full item data, but no borrowernumber or checkout info (no issue)
1890     my $hbr = GetBranchItemRule($item->homebranch, $itemtype)->{'returnbranch'} || "homebranch";
1891         # get the proper branch to which to return the item
1892     my $returnbranch = $hbr ne 'noreturn' ? $item->$hbr : $branch;
1893         # if $hbr was "noreturn" or any other non-item table value, then it should 'float' (i.e. stay at this branch)
1894     my $transfer_trigger = $hbr eq 'homebranch' ? 'ReturnToHome' : $hbr eq 'holdingbranch' ? 'ReturnToHolding' : undef;
1895
1896     my $borrowernumber = $patron ? $patron->borrowernumber : undef;    # we don't know if we had a borrower or not
1897     my $patron_unblessed = $patron ? $patron->unblessed : {};
1898
1899     my $update_loc_rules = get_yaml_pref_hash('UpdateItemLocationOnCheckin');
1900     map { $update_loc_rules->{$_} = $update_loc_rules->{$_}[0] } keys %$update_loc_rules; #We can only move to one location so we flatten the arrays
1901     if ($update_loc_rules) {
1902         if (defined $update_loc_rules->{_ALL_}) {
1903             if ($update_loc_rules->{_ALL_} eq '_PERM_') { $update_loc_rules->{_ALL_} = $item->permanent_location; }
1904             if ($update_loc_rules->{_ALL_} eq '_BLANK_') { $update_loc_rules->{_ALL_} = ''; }
1905             if ( defined $item->location && $item->location ne $update_loc_rules->{_ALL_}) {
1906                 $messages->{'ItemLocationUpdated'} = { from => $item->location, to => $update_loc_rules->{_ALL_} };
1907                 $item->location($update_loc_rules->{_ALL_})->store({skip_record_index=>1});
1908             }
1909         }
1910         else {
1911             foreach my $key ( keys %$update_loc_rules ) {
1912                 if ( $update_loc_rules->{$key} eq '_PERM_' ) { $update_loc_rules->{$key} = $item->permanent_location; }
1913                 if ( $update_loc_rules->{$key} eq '_BLANK_') { $update_loc_rules->{$key} = '' ;}
1914                 if ( ($item->location eq $key && $item->location ne $update_loc_rules->{$key}) || ($key eq '_BLANK_' && $item->location eq '' && $update_loc_rules->{$key} ne '') ) {
1915                     $messages->{'ItemLocationUpdated'} = { from => $item->location, to => $update_loc_rules->{$key} };
1916                     $item->location($update_loc_rules->{$key})->store({skip_record_index=>1});
1917                     last;
1918                 }
1919             }
1920         }
1921     }
1922
1923     my $yaml = C4::Context->preference('UpdateNotForLoanStatusOnCheckin');
1924     if ($yaml) {
1925         $yaml = "$yaml\n\n";  # YAML is anal on ending \n. Surplus does not hurt
1926         my $rules;
1927         eval { $rules = YAML::Load($yaml); };
1928         if ($@) {
1929             warn "Unable to parse UpdateNotForLoanStatusOnCheckin syspref : $@";
1930         }
1931         else {
1932             foreach my $key ( keys %$rules ) {
1933                 if ( $item->notforloan eq $key ) {
1934                     $messages->{'NotForLoanStatusUpdated'} = { from => $item->notforloan, to => $rules->{$key} };
1935                     $item->notforloan($rules->{$key})->store({ log_action => 0, skip_record_index => 1 });
1936                     last;
1937                 }
1938             }
1939         }
1940     }
1941
1942     # check if the return is allowed at this branch
1943     my ($returnallowed, $message) = CanBookBeReturned($item->unblessed, $branch);
1944     unless ($returnallowed){
1945         $messages->{'Wrongbranch'} = {
1946             Wrongbranch => $branch,
1947             Rightbranch => $message
1948         };
1949         $doreturn = 0;
1950         my $indexer = Koha::SearchEngine::Indexer->new({ index => $Koha::SearchEngine::BIBLIOS_INDEX });
1951         $indexer->index_records( $item->biblionumber, "specialUpdate", "biblioserver" );
1952         return ( $doreturn, $messages, $issue, $patron_unblessed);
1953     }
1954
1955     if ( $item->withdrawn ) { # book has been cancelled
1956         $messages->{'withdrawn'} = 1;
1957         $doreturn = 0 if C4::Context->preference("BlockReturnOfWithdrawnItems");
1958     }
1959
1960     if ( $item->itemlost and C4::Context->preference("BlockReturnOfLostItems") ) {
1961         $doreturn = 0;
1962     }
1963
1964     # case of a return of document (deal with issues and holdingbranch)
1965     if ($doreturn) {
1966         die "The item is not issed and cannot be returned" unless $issue; # Just in case...
1967         $patron or warn "AddReturn without current borrower";
1968
1969         if ($patron) {
1970             eval {
1971                 MarkIssueReturned( $borrowernumber, $item->itemnumber, $return_date, $patron->privacy, { skip_record_index => 1} );
1972             };
1973             unless ( $@ ) {
1974                 if (
1975                     (
1976                         C4::Context->preference('CalculateFinesOnReturn')
1977                         || ( $return_date_specified && C4::Context->preference('CalculateFinesOnBackdate') )
1978                     )
1979                     && !$item->itemlost
1980                   )
1981                 {
1982                     _CalculateAndUpdateFine( { issue => $issue, item => $item->unblessed, borrower => $patron_unblessed, return_date => $return_date } );
1983                 }
1984             } else {
1985                 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 );
1986
1987                 my $indexer = Koha::SearchEngine::Indexer->new({ index => $Koha::SearchEngine::BIBLIOS_INDEX });
1988                 $indexer->index_records( $item->biblionumber, "specialUpdate", "biblioserver" );
1989
1990                 return ( 0, { WasReturned => 0, DataCorrupted => 1 }, $issue, $patron_unblessed );
1991             }
1992
1993             # FIXME is the "= 1" right?  This could be the borrower hash.
1994             $messages->{'WasReturned'} = 1;
1995
1996         } else {
1997             $item->onloan(undef)->store({ log_action => 0 , skip_record_index => 1 });
1998         }
1999     }
2000
2001     # the holdingbranch is updated if the document is returned to another location.
2002     # this is always done regardless of whether the item was on loan or not
2003     my $item_holding_branch = $item->holdingbranch;
2004     if ($item->holdingbranch ne $branch) {
2005         $item->holdingbranch($branch)->store({ skip_record_index => 1 });
2006     }
2007
2008     my $leave_item_lost = C4::Context->preference("BlockReturnOfLostItems") ? 1 : 0;
2009     ModDateLastSeen( $item->itemnumber, $leave_item_lost, { skip_record_index => 1 } );
2010
2011     # check if we have a transfer for this document
2012     my ($datesent,$frombranch,$tobranch) = GetTransfers( $item->itemnumber );
2013
2014     # if we have a transfer to do, we update the line of transfers with the datearrived
2015     my $is_in_rotating_collection = C4::RotatingCollections::isItemInAnyCollection( $item->itemnumber );
2016     if ($datesent) {
2017         # At this point we will either fill the transfer or it is a wrong transfer
2018         # either way we should not now generate a new transfer
2019         $validTransfer = 0;
2020         if ( $tobranch eq $branch ) {
2021             my $sth = C4::Context->dbh->prepare(
2022                 "UPDATE branchtransfers SET datearrived = now() WHERE itemnumber= ? AND datearrived IS NULL"
2023             );
2024             $sth->execute( $item->itemnumber );
2025         } else {
2026             $messages->{'WrongTransfer'}     = $tobranch;
2027             $messages->{'WrongTransferItem'} = $item->itemnumber;
2028         }
2029     }
2030
2031     # fix up the accounts.....
2032     if ( $item->itemlost ) {
2033         $messages->{'WasLost'} = 1;
2034         unless ( C4::Context->preference("BlockReturnOfLostItems") ) {
2035             if (
2036                 Koha::RefundLostItemFeeRules->should_refund(
2037                     {
2038                         current_branch      => C4::Context->userenv->{branch},
2039                         item_home_branch    => $item->homebranch,
2040                         item_holding_branch => $item_holding_branch
2041                     }
2042                 )
2043               )
2044             {
2045                 _FixAccountForLostAndFound( $item->itemnumber,
2046                     $borrowernumber, $barcode );
2047                 $messages->{'LostItemFeeRefunded'} = 1;
2048             }
2049         }
2050     }
2051
2052     # fix up the overdues in accounts...
2053     if ($borrowernumber) {
2054         my $fix = _FixOverduesOnReturn( $borrowernumber, $item->itemnumber, $exemptfine, 'RETURNED' );
2055         defined($fix) or warn "_FixOverduesOnReturn($borrowernumber, ".$item->itemnumber."...) failed!";  # zero is OK, check defined
2056
2057         if ( $issue and $issue->is_overdue($return_date) ) {
2058         # fix fine days
2059             my ($debardate,$reminder) = _debar_user_on_return( $patron_unblessed, $item->unblessed, dt_from_string($issue->date_due), $return_date );
2060             if ($reminder){
2061                 $messages->{'PrevDebarred'} = $debardate;
2062             } else {
2063                 $messages->{'Debarred'} = $debardate if $debardate;
2064             }
2065         # there's no overdue on the item but borrower had been previously debarred
2066         } elsif ( $issue->date_due and $patron->debarred ) {
2067              if ( $patron->debarred eq "9999-12-31") {
2068                 $messages->{'ForeverDebarred'} = $patron->debarred;
2069              } else {
2070                   my $borrower_debar_dt = dt_from_string( $patron->debarred );
2071                   $borrower_debar_dt->truncate(to => 'day');
2072                   my $today_dt = $return_date->clone()->truncate(to => 'day');
2073                   if ( DateTime->compare( $borrower_debar_dt, $today_dt ) != -1 ) {
2074                       $messages->{'PrevDebarred'} = $patron->debarred;
2075                   }
2076              }
2077         }
2078     }
2079
2080     # find reserves.....
2081     # launch the Checkreserves routine to find any holds
2082     my ($resfound, $resrec);
2083     my $lookahead= C4::Context->preference('ConfirmFutureHolds'); #number of days to look for future holds
2084     ($resfound, $resrec, undef) = C4::Reserves::CheckReserves( $item->itemnumber, undef, $lookahead ) unless ( $item->withdrawn );
2085     # 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)
2086     if ( $resfound eq "Waiting" and $branch ne $resrec->{branchcode} ) {
2087         my $hold = C4::Reserves::RevertWaitingStatus( { itemnumber => $item->itemnumber } );
2088         $resfound = 'Reserved';
2089         $resrec = $hold->unblessed;
2090     }
2091     if ($resfound) {
2092           $resrec->{'ResFound'} = $resfound;
2093         $messages->{'ResFound'} = $resrec;
2094     }
2095
2096     # Record the fact that this book was returned.
2097     UpdateStats({
2098         branch         => $branch,
2099         type           => $stat_type,
2100         itemnumber     => $itemnumber,
2101         itemtype       => $itemtype,
2102         borrowernumber => $borrowernumber,
2103         ccode          => $item->ccode,
2104     });
2105
2106     # Send a check-in slip. # NOTE: borrower may be undef. Do not try to send messages then.
2107     if ( $patron ) {
2108         my $circulation_alert = 'C4::ItemCirculationAlertPreference';
2109         my %conditions = (
2110             branchcode   => $branch,
2111             categorycode => $patron->categorycode,
2112             item_type    => $itemtype,
2113             notification => 'CHECKIN',
2114         );
2115         if ($doreturn && $circulation_alert->is_enabled_for(\%conditions)) {
2116             SendCirculationAlert({
2117                 type     => 'CHECKIN',
2118                 item     => $item->unblessed,
2119                 borrower => $patron->unblessed,
2120                 branch   => $branch,
2121             });
2122         }
2123
2124         logaction("CIRCULATION", "RETURN", $borrowernumber, $item->itemnumber)
2125             if C4::Context->preference("ReturnLog");
2126         }
2127
2128     # Check if this item belongs to a biblio record that is attached to an
2129     # ILL request, if it is we need to update the ILL request's status
2130     if ( $doreturn and C4::Context->preference('CirculateILL')) {
2131         my $request = Koha::Illrequests->find(
2132             { biblio_id => $item->biblio->biblionumber }
2133         );
2134         $request->status('RET') if $request;
2135     }
2136
2137     # Transfer to returnbranch if Automatic transfer set or append message NeedsTransfer
2138     if ($validTransfer && !$is_in_rotating_collection && ($doreturn or $messages->{'NotIssued'}) and !$resfound and ($branch ne $returnbranch) ){
2139         my $BranchTransferLimitsType = C4::Context->preference("BranchTransferLimitsType") eq 'itemtype' ? 'effective_itemtype' : 'ccode';
2140         if  (C4::Context->preference("AutomaticItemReturn"    ) or
2141             (C4::Context->preference("UseBranchTransferLimits") and
2142              ! IsBranchTransferAllowed($branch, $returnbranch, $item->$BranchTransferLimitsType )
2143            )) {
2144             $debug and warn sprintf "about to call ModItemTransfer(%s, %s, %s, %s)", $item->itemnumber,$branch, $returnbranch, $transfer_trigger;
2145             $debug and warn "item: " . Dumper($item->unblessed);
2146             ModItemTransfer($item->itemnumber, $branch, $returnbranch, $transfer_trigger, { skip_record_index => 1 });
2147             $messages->{'WasTransfered'} = 1;
2148         } else {
2149             $messages->{'NeedsTransfer'} = $returnbranch;
2150             $messages->{'TransferTrigger'} = $transfer_trigger;
2151         }
2152     }
2153
2154     if ( C4::Context->preference('ClaimReturnedLostValue') ) {
2155         my $claims = Koha::Checkouts::ReturnClaims->search(
2156            {
2157                itemnumber => $item->id,
2158                resolution => undef,
2159            }
2160         );
2161
2162         if ( $claims->count ) {
2163             $messages->{ReturnClaims} = $claims;
2164         }
2165     }
2166
2167     my $indexer = Koha::SearchEngine::Indexer->new({ index => $Koha::SearchEngine::BIBLIOS_INDEX });
2168     $indexer->index_records( $item->biblionumber, "specialUpdate", "biblioserver" );
2169
2170     return ( $doreturn, $messages, $issue, ( $patron ? $patron->unblessed : {} ));
2171 }
2172
2173 =head2 MarkIssueReturned
2174
2175   MarkIssueReturned($borrowernumber, $itemnumber, $returndate, $privacy, [$params] );
2176
2177 Unconditionally marks an issue as being returned by
2178 moving the C<issues> row to C<old_issues> and
2179 setting C<returndate> to the current date.
2180
2181 if C<$returndate> is specified (in iso format), it is used as the date
2182 of the return.
2183
2184 C<$privacy> contains the privacy parameter. If the patron has set privacy to 2,
2185 the old_issue is immediately anonymised
2186
2187 Ideally, this function would be internal to C<C4::Circulation>,
2188 not exported, but it is currently used in misc/cronjobs/longoverdue.pl
2189 and offline_circ/process_koc.pl.
2190
2191 The last optional parameter allos passing skip_record_index to the item store call.
2192
2193 =cut
2194
2195 sub MarkIssueReturned {
2196     my ( $borrowernumber, $itemnumber, $returndate, $privacy, $params ) = @_;
2197
2198     # Retrieve the issue
2199     my $issue = Koha::Checkouts->find( { itemnumber => $itemnumber } ) or return;
2200
2201     return unless $issue->borrowernumber == $borrowernumber; # If the item is checked out to another patron we do not return it
2202
2203     my $issue_id = $issue->issue_id;
2204
2205     my $anonymouspatron;
2206     if ( $privacy && $privacy == 2 ) {
2207         # The default of 0 will not work due to foreign key constraints
2208         # The anonymisation will fail if AnonymousPatron is not a valid entry
2209         # We need to check if the anonymous patron exist, Koha will fail loudly if it does not
2210         # Note that a warning should appear on the about page (System information tab).
2211         $anonymouspatron = C4::Context->preference('AnonymousPatron');
2212         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."
2213             unless Koha::Patrons->find( $anonymouspatron );
2214     }
2215
2216     my $schema = Koha::Database->schema;
2217
2218     # FIXME Improve the return value and handle it from callers
2219     $schema->txn_do(sub {
2220
2221         my $patron = Koha::Patrons->find( $borrowernumber );
2222
2223         # Update the returndate value
2224         if ( $returndate ) {
2225             $issue->returndate( $returndate )->store->discard_changes; # update and refetch
2226         }
2227         else {
2228             $issue->returndate( \'NOW()' )->store->discard_changes; # update and refetch
2229         }
2230
2231         # Create the old_issues entry
2232         my $old_checkout = Koha::Old::Checkout->new($issue->unblessed)->store;
2233
2234         # anonymise patron checkout immediately if $privacy set to 2 and AnonymousPatron is set to a valid borrowernumber
2235         if ( $privacy && $privacy == 2) {
2236             $old_checkout->borrowernumber($anonymouspatron)->store;
2237         }
2238
2239         # And finally delete the issue
2240         $issue->delete;
2241
2242         $issue->item->onloan(undef)->store({ log_action => 0, skip_record_index => $params->{skip_record_index} });
2243
2244         if ( C4::Context->preference('StoreLastBorrower') ) {
2245             my $item = Koha::Items->find( $itemnumber );
2246             $item->last_returned_by( $patron );
2247         }
2248
2249         # Remove any OVERDUES related debarment if the borrower has no overdues
2250         if ( C4::Context->preference('AutoRemoveOverduesRestrictions')
2251           && $patron->debarred
2252           && !$patron->has_overdues
2253           && @{ GetDebarments({ borrowernumber => $borrowernumber, type => 'OVERDUES' }) }
2254         ) {
2255             DelUniqueDebarment({ borrowernumber => $borrowernumber, type => 'OVERDUES' });
2256         }
2257
2258     });
2259
2260     return $issue_id;
2261 }
2262
2263 =head2 _debar_user_on_return
2264
2265     _debar_user_on_return($borrower, $item, $datedue, $returndate);
2266
2267 C<$borrower> borrower hashref
2268
2269 C<$item> item hashref
2270
2271 C<$datedue> date due DateTime object
2272
2273 C<$returndate> DateTime object representing the return time
2274
2275 Internal function, called only by AddReturn that calculates and updates
2276  the user fine days, and debars them if necessary.
2277
2278 Should only be called for overdue returns
2279
2280 Calculation of the debarment date has been moved to a separate subroutine _calculate_new_debar_dt
2281 to ease testing.
2282
2283 =cut
2284
2285 sub _calculate_new_debar_dt {
2286     my ( $borrower, $item, $dt_due, $return_date ) = @_;
2287
2288     my $branchcode = _GetCircControlBranch( $item, $borrower );
2289     my $circcontrol = C4::Context->preference('CircControl');
2290     my $issuing_rule = Koha::CirculationRules->get_effective_rules(
2291         {   categorycode => $borrower->{categorycode},
2292             itemtype     => $item->{itype},
2293             branchcode   => $branchcode,
2294             rules => [
2295                 'finedays',
2296                 'lengthunit',
2297                 'firstremind',
2298                 'maxsuspensiondays',
2299                 'suspension_chargeperiod',
2300             ]
2301         }
2302     );
2303     my $finedays = $issuing_rule ? $issuing_rule->{finedays} : undef;
2304     my $unit     = $issuing_rule ? $issuing_rule->{lengthunit} : undef;
2305     my $chargeable_units = C4::Overdues::get_chargeable_units($unit, $dt_due, $return_date, $branchcode);
2306
2307     return unless $finedays;
2308
2309     # finedays is in days, so hourly loans must multiply by 24
2310     # thus 1 hour late equals 1 day suspension * finedays rate
2311     $finedays = $finedays * 24 if ( $unit eq 'hours' );
2312
2313     # grace period is measured in the same units as the loan
2314     my $grace =
2315       DateTime::Duration->new( $unit => $issuing_rule->{firstremind} // 0);
2316
2317     my $deltadays = DateTime::Duration->new(
2318         days => $chargeable_units
2319     );
2320
2321     if ( $deltadays->subtract($grace)->is_positive() ) {
2322         my $suspension_days = $deltadays * $finedays;
2323
2324         if ( defined $issuing_rule->{suspension_chargeperiod} && $issuing_rule->{suspension_chargeperiod} > 1 ) {
2325             # No need to / 1 and do not consider / 0
2326             $suspension_days = DateTime::Duration->new(
2327                 days => floor( $suspension_days->in_units('days') / $issuing_rule->{suspension_chargeperiod} )
2328             );
2329         }
2330
2331         # If the max suspension days is < than the suspension days
2332         # the suspension days is limited to this maximum period.
2333         my $max_sd = $issuing_rule->{maxsuspensiondays};
2334         if ( defined $max_sd && $max_sd ne '' ) {
2335             $max_sd = DateTime::Duration->new( days => $max_sd );
2336             $suspension_days = $max_sd
2337               if DateTime::Duration->compare( $max_sd, $suspension_days ) < 0;
2338         }
2339
2340         my ( $has_been_extended );
2341         if ( C4::Context->preference('CumulativeRestrictionPeriods') and $borrower->{debarred} ) {
2342             my $debarment = @{ GetDebarments( { borrowernumber => $borrower->{borrowernumber}, type => 'SUSPENSION' } ) }[0];
2343             if ( $debarment ) {
2344                 $return_date = dt_from_string( $debarment->{expiration}, 'sql' );
2345                 $has_been_extended = 1;
2346             }
2347         }
2348
2349         my $new_debar_dt;
2350         # Use the calendar or not to calculate the debarment date
2351         if ( C4::Context->preference('SuspensionsCalendar') eq 'noSuspensionsWhenClosed' ) {
2352             my $calendar = Koha::Calendar->new(
2353                 branchcode => $branchcode,
2354                 days_mode  => 'Calendar'
2355             );
2356             $new_debar_dt = $calendar->addDate( $return_date, $suspension_days );
2357         }
2358         else {
2359             $new_debar_dt = $return_date->clone()->add_duration($suspension_days);
2360         }
2361         return $new_debar_dt;
2362     }
2363     return;
2364 }
2365
2366 sub _debar_user_on_return {
2367     my ( $borrower, $item, $dt_due, $return_date ) = @_;
2368
2369     $return_date //= dt_from_string();
2370
2371     my $new_debar_dt = _calculate_new_debar_dt ($borrower, $item, $dt_due, $return_date);
2372
2373     return unless $new_debar_dt;
2374
2375     Koha::Patron::Debarments::AddUniqueDebarment({
2376         borrowernumber => $borrower->{borrowernumber},
2377         expiration     => $new_debar_dt->ymd(),
2378         type           => 'SUSPENSION',
2379     });
2380     # if borrower was already debarred but does not get an extra debarment
2381     my $patron = Koha::Patrons->find( $borrower->{borrowernumber} );
2382     my ($new_debarment_str, $is_a_reminder);
2383     if ( $borrower->{debarred} && $borrower->{debarred} eq $patron->is_debarred ) {
2384         $is_a_reminder = 1;
2385         $new_debarment_str = $borrower->{debarred};
2386     } else {
2387         $new_debarment_str = $new_debar_dt->ymd();
2388     }
2389     # FIXME Should return a DateTime object
2390     return $new_debarment_str, $is_a_reminder;
2391 }
2392
2393 =head2 _FixOverduesOnReturn
2394
2395    &_FixOverduesOnReturn($borrowernumber, $itemnumber, $exemptfine, $status);
2396
2397 C<$borrowernumber> borrowernumber
2398
2399 C<$itemnumber> itemnumber
2400
2401 C<$exemptfine> BOOL -- remove overdue charge associated with this issue.
2402
2403 C<$status> ENUM -- reason for fix [ RETURNED, RENEWED, LOST, FORGIVEN ]
2404
2405 Internal function
2406
2407 =cut
2408
2409 sub _FixOverduesOnReturn {
2410     my ( $borrowernumber, $item, $exemptfine, $status ) = @_;
2411     unless( $borrowernumber ) {
2412         warn "_FixOverduesOnReturn() not supplied valid borrowernumber";
2413         return;
2414     }
2415     unless( $item ) {
2416         warn "_FixOverduesOnReturn() not supplied valid itemnumber";
2417         return;
2418     }
2419     unless( $status ) {
2420         warn "_FixOverduesOnReturn() not supplied valid status";
2421         return;
2422     }
2423
2424     my $schema = Koha::Database->schema;
2425
2426     my $result = $schema->txn_do(
2427         sub {
2428             # check for overdue fine
2429             my $accountlines = Koha::Account::Lines->search(
2430                 {
2431                     borrowernumber  => $borrowernumber,
2432                     itemnumber      => $item,
2433                     debit_type_code => 'OVERDUE',
2434                     status          => 'UNRETURNED'
2435                 }
2436             );
2437             return 0 unless $accountlines->count; # no warning, there's just nothing to fix
2438
2439             my $accountline = $accountlines->next;
2440             my $payments = $accountline->credits;
2441
2442             my $amountoutstanding = $accountline->amountoutstanding;
2443             if ( $accountline->amount == 0 && $payments->count == 0 ) {
2444                 $accountline->delete;
2445             } elsif ($exemptfine && ($amountoutstanding != 0)) {
2446                 my $account = Koha::Account->new({patron_id => $borrowernumber});
2447                 my $credit = $account->add_credit(
2448                     {
2449                         amount     => $amountoutstanding,
2450                         user_id    => C4::Context->userenv ? C4::Context->userenv->{'number'} : undef,
2451                         library_id => C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef,
2452                         interface  => C4::Context->interface,
2453                         type       => 'FORGIVEN',
2454                         item_id    => $item
2455                     }
2456                 );
2457
2458                 $credit->apply({ debits => [ $accountline ], offset_type => 'Forgiven' });
2459
2460                 if (C4::Context->preference("FinesLog")) {
2461                     &logaction("FINES", 'MODIFY',$borrowernumber,"Overdue forgiven: item $item");
2462                 }
2463
2464                 $accountline->status('FORGIVEN');
2465                 $accountline->store();
2466             } else {
2467                 $accountline->status($status);
2468                 $accountline->store();
2469
2470             }
2471         }
2472     );
2473
2474     return $result;
2475 }
2476
2477 =head2 _FixAccountForLostAndFound
2478
2479   &_FixAccountForLostAndFound($itemnumber, [$borrowernumber, $barcode]);
2480
2481 Finds the most recent lost item charge for this item and refunds the borrower
2482 appropriatly, taking into account any payments or writeoffs already applied
2483 against the charge.
2484
2485 Internal function, not exported, called only by AddReturn.
2486
2487 =cut
2488
2489 sub _FixAccountForLostAndFound {
2490     my $itemnumber     = shift or return;
2491     my $borrowernumber = @_ ? shift : undef;
2492     my $item_id        = @_ ? shift : $itemnumber;  # Send the barcode if you want that logged in the description
2493
2494     my $credit;
2495
2496     # check for charge made for lost book
2497     my $accountlines = Koha::Account::Lines->search(
2498         {
2499             itemnumber      => $itemnumber,
2500             debit_type_code => 'LOST',
2501             status          => [ undef, { '<>' => 'FOUND' } ]
2502         },
2503         {
2504             order_by => { -desc => [ 'date', 'accountlines_id' ] }
2505         }
2506     );
2507
2508     return unless $accountlines->count > 0;
2509     my $accountline     = $accountlines->next;
2510     my $total_to_refund = 0;
2511
2512     return unless $accountline->borrowernumber;
2513     my $patron = Koha::Patrons->find( $accountline->borrowernumber );
2514     return unless $patron; # Patron has been deleted, nobody to credit the return to
2515
2516     my $account = $patron->account;
2517
2518     # Use cases
2519     if ( $accountline->amount > $accountline->amountoutstanding ) {
2520         # some amount has been cancelled. collect the offsets that are not writeoffs
2521         # this works because the only way to subtract from this kind of a debt is
2522         # using the UI buttons 'Pay' and 'Write off'
2523         my $credits_offsets = Koha::Account::Offsets->search({
2524             debit_id  => $accountline->id,
2525             credit_id => { '!=' => undef }, # it is not the debit itself
2526             type      => { '!=' => 'Writeoff' },
2527             amount    => { '<'  => 0 } # credits are negative on the DB
2528         });
2529
2530         $total_to_refund = ( $credits_offsets->count > 0 )
2531                             ? $credits_offsets->total * -1 # credits are negative on the DB
2532                             : 0;
2533     }
2534
2535     my $credit_total = $accountline->amountoutstanding + $total_to_refund;
2536
2537     if ( $credit_total > 0 ) {
2538         my $branchcode = C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
2539         $credit = $account->add_credit(
2540             {
2541                 amount      => $credit_total,
2542                 description => 'Item found ' . $item_id,
2543                 type        => 'LOST_FOUND',
2544                 interface   => C4::Context->interface,
2545                 library_id  => $branchcode,
2546                 item_id     => $itemnumber
2547             }
2548         );
2549
2550         $credit->apply( { debits => [ $accountline ] } );
2551     }
2552
2553     # Update the account status
2554     $accountline->discard_changes->status('FOUND');
2555     $accountline->store;
2556
2557     $accountline->item->paidfor('')->store({ log_action => 0 });
2558
2559     if ( defined $account and C4::Context->preference('AccountAutoReconcile') ) {
2560         $account->reconcile_balance;
2561     }
2562
2563     return ($credit) ? $credit->id : undef;
2564 }
2565
2566 =head2 _GetCircControlBranch
2567
2568    my $circ_control_branch = _GetCircControlBranch($iteminfos, $borrower);
2569
2570 Internal function :
2571
2572 Return the library code to be used to determine which circulation
2573 policy applies to a transaction.  Looks up the CircControl and
2574 HomeOrHoldingBranch system preferences.
2575
2576 C<$iteminfos> is a hashref to iteminfo. Only {homebranch or holdingbranch} is used.
2577
2578 C<$borrower> is a hashref to borrower. Only {branchcode} is used.
2579
2580 =cut
2581
2582 sub _GetCircControlBranch {
2583     my ($item, $borrower) = @_;
2584     my $circcontrol = C4::Context->preference('CircControl');
2585     my $branch;
2586
2587     if ($circcontrol eq 'PickupLibrary' and (C4::Context->userenv and C4::Context->userenv->{'branch'}) ) {
2588         $branch= C4::Context->userenv->{'branch'};
2589     } elsif ($circcontrol eq 'PatronLibrary') {
2590         $branch=$borrower->{branchcode};
2591     } else {
2592         my $branchfield = C4::Context->preference('HomeOrHoldingBranch') || 'homebranch';
2593         $branch = $item->{$branchfield};
2594         # default to item home branch if holdingbranch is used
2595         # and is not defined
2596         if (!defined($branch) && $branchfield eq 'holdingbranch') {
2597             $branch = $item->{homebranch};
2598         }
2599     }
2600     return $branch;
2601 }
2602
2603 =head2 GetOpenIssue
2604
2605   $issue = GetOpenIssue( $itemnumber );
2606
2607 Returns the row from the issues table if the item is currently issued, undef if the item is not currently issued
2608
2609 C<$itemnumber> is the item's itemnumber
2610
2611 Returns a hashref
2612
2613 =cut
2614
2615 sub GetOpenIssue {
2616   my ( $itemnumber ) = @_;
2617   return unless $itemnumber;
2618   my $dbh = C4::Context->dbh;
2619   my $sth = $dbh->prepare( "SELECT * FROM issues WHERE itemnumber = ? AND returndate IS NULL" );
2620   $sth->execute( $itemnumber );
2621   return $sth->fetchrow_hashref();
2622
2623 }
2624
2625 =head2 GetUpcomingDueIssues
2626
2627   my $upcoming_dues = GetUpcomingDueIssues( { days_in_advance => 4 } );
2628
2629 =cut
2630
2631 sub GetUpcomingDueIssues {
2632     my $params = shift;
2633
2634     $params->{'days_in_advance'} = 7 unless exists $params->{'days_in_advance'};
2635     my $dbh = C4::Context->dbh;
2636
2637     my $statement = <<END_SQL;
2638 SELECT *
2639 FROM (
2640     SELECT issues.*, items.itype as itemtype, items.homebranch, TO_DAYS( date_due )-TO_DAYS( NOW() ) as days_until_due, branches.branchemail
2641     FROM issues
2642     LEFT JOIN items USING (itemnumber)
2643     LEFT OUTER JOIN branches USING (branchcode)
2644     WHERE returndate is NULL
2645 ) tmp
2646 WHERE days_until_due >= 0 AND days_until_due <= ?
2647 END_SQL
2648
2649     my @bind_parameters = ( $params->{'days_in_advance'} );
2650
2651     my $sth = $dbh->prepare( $statement );
2652     $sth->execute( @bind_parameters );
2653     my $upcoming_dues = $sth->fetchall_arrayref({});
2654
2655     return $upcoming_dues;
2656 }
2657
2658 =head2 CanBookBeRenewed
2659
2660   ($ok,$error) = &CanBookBeRenewed($borrowernumber, $itemnumber[, $override_limit]);
2661
2662 Find out whether a borrowed item may be renewed.
2663
2664 C<$borrowernumber> is the borrower number of the patron who currently
2665 has the item on loan.
2666
2667 C<$itemnumber> is the number of the item to renew.
2668
2669 C<$override_limit>, if supplied with a true value, causes
2670 the limit on the number of times that the loan can be renewed
2671 (as controlled by the item type) to be ignored. Overriding also allows
2672 to renew sooner than "No renewal before" and to manually renew loans
2673 that are automatically renewed.
2674
2675 C<$CanBookBeRenewed> returns a true value if the item may be renewed. The
2676 item must currently be on loan to the specified borrower; renewals
2677 must be allowed for the item's type; and the borrower must not have
2678 already renewed the loan. $error will contain the reason the renewal can not proceed
2679
2680 =cut
2681
2682 sub CanBookBeRenewed {
2683     my ( $borrowernumber, $itemnumber, $override_limit, $cron ) = @_;
2684
2685     my $dbh    = C4::Context->dbh;
2686     my $renews = 1;
2687     my $auto_renew = "no";
2688
2689     my $item      = Koha::Items->find($itemnumber)      or return ( 0, 'no_item' );
2690     my $issue = $item->checkout or return ( 0, 'no_checkout' );
2691     return ( 0, 'onsite_checkout' ) if $issue->onsite_checkout;
2692     return ( 0, 'item_denied_renewal') if _item_denied_renewal({ item => $item });
2693
2694     my $patron = $issue->patron or return;
2695
2696     # override_limit will override anything else except on_reserve
2697     unless ( $override_limit ){
2698         my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
2699         my $issuing_rule = Koha::CirculationRules->get_effective_rules(
2700             {
2701                 categorycode => $patron->categorycode,
2702                 itemtype     => $item->effective_itemtype,
2703                 branchcode   => $branchcode,
2704                 rules => [
2705                     'renewalsallowed',
2706                     'no_auto_renewal_after',
2707                     'no_auto_renewal_after_hard_limit',
2708                     'lengthunit',
2709                     'norenewalbefore',
2710                 ]
2711             }
2712         );
2713
2714         return ( 0, "too_many" )
2715           if not $issuing_rule->{renewalsallowed} or $issuing_rule->{renewalsallowed} <= $issue->renewals;
2716
2717         my $overduesblockrenewing = C4::Context->preference('OverduesBlockRenewing');
2718         my $restrictionblockrenewing = C4::Context->preference('RestrictionBlockRenewing');
2719         $patron         = Koha::Patrons->find($borrowernumber); # FIXME Is this really useful?
2720         my $restricted  = $patron->is_debarred;
2721         my $hasoverdues = $patron->has_overdues;
2722
2723         if ( $restricted and $restrictionblockrenewing ) {
2724             return ( 0, 'restriction');
2725         } elsif ( ($hasoverdues and $overduesblockrenewing eq 'block') || ($issue->is_overdue and $overduesblockrenewing eq 'blockitem') ) {
2726             return ( 0, 'overdue');
2727         }
2728
2729         if ( $issue->auto_renew && $patron->autorenew_checkouts ) {
2730
2731             if ( $patron->category->effective_BlockExpiredPatronOpacActions and $patron->is_expired ) {
2732                 return ( 0, 'auto_account_expired' );
2733             }
2734
2735             if ( defined $issuing_rule->{no_auto_renewal_after}
2736                     and $issuing_rule->{no_auto_renewal_after} ne "" ) {
2737                 # Get issue_date and add no_auto_renewal_after
2738                 # If this is greater than today, it's too late for renewal.
2739                 my $maximum_renewal_date = dt_from_string($issue->issuedate, 'sql');
2740                 $maximum_renewal_date->add(
2741                     $issuing_rule->{lengthunit} => $issuing_rule->{no_auto_renewal_after}
2742                 );
2743                 my $now = dt_from_string;
2744                 if ( $now >= $maximum_renewal_date ) {
2745                     return ( 0, "auto_too_late" );
2746                 }
2747             }
2748             if ( defined $issuing_rule->{no_auto_renewal_after_hard_limit}
2749                           and $issuing_rule->{no_auto_renewal_after_hard_limit} ne "" ) {
2750                 # If no_auto_renewal_after_hard_limit is >= today, it's also too late for renewal
2751                 if ( dt_from_string >= dt_from_string( $issuing_rule->{no_auto_renewal_after_hard_limit} ) ) {
2752                     return ( 0, "auto_too_late" );
2753                 }
2754             }
2755
2756             if ( C4::Context->preference('OPACFineNoRenewalsBlockAutoRenew') ) {
2757                 my $fine_no_renewals = C4::Context->preference("OPACFineNoRenewals");
2758                 my $amountoutstanding =
2759                   C4::Context->preference("OPACFineNoRenewalsIncludeCredit")
2760                   ? $patron->account->balance
2761                   : $patron->account->outstanding_debits->total_outstanding;
2762                 if ( $amountoutstanding and $amountoutstanding > $fine_no_renewals ) {
2763                     return ( 0, "auto_too_much_oweing" );
2764                 }
2765             }
2766         }
2767
2768         if ( defined $issuing_rule->{norenewalbefore}
2769             and $issuing_rule->{norenewalbefore} ne "" )
2770         {
2771
2772             # Calculate soonest renewal by subtracting 'No renewal before' from due date
2773             my $soonestrenewal = dt_from_string( $issue->date_due, 'sql' )->subtract(
2774                 $issuing_rule->{lengthunit} => $issuing_rule->{norenewalbefore} );
2775
2776             # Depending on syspref reset the exact time, only check the date
2777             if ( C4::Context->preference('NoRenewalBeforePrecision') eq 'date'
2778                 and $issuing_rule->{lengthunit} eq 'days' )
2779             {
2780                 $soonestrenewal->truncate( to => 'day' );
2781             }
2782
2783             if ( $soonestrenewal > dt_from_string() )
2784             {
2785                 $auto_renew = ($issue->auto_renew && $patron->autorenew_checkouts) ? "auto_too_soon" : "too_soon";
2786             }
2787             elsif ( $issue->auto_renew && $patron->autorenew_checkouts ) {
2788                 $auto_renew = "ok";
2789             }
2790         }
2791
2792         # Fallback for automatic renewals:
2793         # If norenewalbefore is undef, don't renew before due date.
2794         if ( $issue->auto_renew && $auto_renew eq "no" && $patron->autorenew_checkouts ) {
2795             my $now = dt_from_string;
2796             if ( $now >= dt_from_string( $issue->date_due, 'sql' ) ){
2797                 $auto_renew = "ok";
2798             } else {
2799                 $auto_renew = "auto_too_soon";
2800             }
2801         }
2802     }
2803
2804     my ( $resfound, $resrec, undef ) = C4::Reserves::CheckReserves($itemnumber);
2805
2806     # This item can fill one or more unfilled reserve, can those unfilled reserves
2807     # all be filled by other available items?
2808     if ( $resfound
2809         && C4::Context->preference('AllowRenewalIfOtherItemsAvailable') )
2810     {
2811         my $schema = Koha::Database->new()->schema();
2812
2813         my $item_holds = $schema->resultset('Reserve')->search( { itemnumber => $itemnumber, found => undef } )->count();
2814         if ($item_holds) {
2815             # There is an item level hold on this item, no other item can fill the hold
2816             $resfound = 1;
2817         }
2818         else {
2819
2820             # Get all other items that could possibly fill reserves
2821             my @itemnumbers = $schema->resultset('Item')->search(
2822                 {
2823                     biblionumber => $resrec->{biblionumber},
2824                     onloan       => undef,
2825                     notforloan   => 0,
2826                     -not         => { itemnumber => $itemnumber }
2827                 },
2828                 { columns => 'itemnumber' }
2829             )->get_column('itemnumber')->all();
2830
2831             # Get all other reserves that could have been filled by this item
2832             my @borrowernumbers;
2833             while (1) {
2834                 my ( $reserve_found, $reserve, undef ) =
2835                   C4::Reserves::CheckReserves( $itemnumber, undef, undef, \@borrowernumbers );
2836
2837                 if ($reserve_found) {
2838                     push( @borrowernumbers, $reserve->{borrowernumber} );
2839                 }
2840                 else {
2841                     last;
2842                 }
2843             }
2844
2845             # If the count of the union of the lists of reservable items for each borrower
2846             # is equal or greater than the number of borrowers, we know that all reserves
2847             # can be filled with available items. We can get the union of the sets simply
2848             # by pushing all the elements onto an array and removing the duplicates.
2849             my @reservable;
2850             my %patrons;
2851             ITEM: foreach my $itemnumber (@itemnumbers) {
2852                 my $item = Koha::Items->find( $itemnumber );
2853                 next if IsItemOnHoldAndFound( $itemnumber );
2854                 for my $borrowernumber (@borrowernumbers) {
2855                     my $patron = $patrons{$borrowernumber} //= Koha::Patrons->find( $borrowernumber );
2856                     next unless IsAvailableForItemLevelRequest($item, $patron);
2857                     next unless CanItemBeReserved($borrowernumber,$itemnumber);
2858
2859                     push @reservable, $itemnumber;
2860                     if (@reservable >= @borrowernumbers) {
2861                         $resfound = 0;
2862                         last ITEM;
2863                     }
2864                     last;
2865                 }
2866             }
2867         }
2868     }
2869     if( $cron ) { #The cron wants to return 'too_soon' over 'on_reserve'
2870         return ( 0, $auto_renew  ) if $auto_renew =~ 'too_soon';#$auto_renew ne "no" && $auto_renew ne "ok";
2871         return ( 0, "on_reserve" ) if $resfound;    # '' when no hold was found
2872     } else { # For other purposes we want 'on_reserve' before 'too_soon'
2873         return ( 0, "on_reserve" ) if $resfound;    # '' when no hold was found
2874         return ( 0, $auto_renew  ) if $auto_renew =~ 'too_soon';#$auto_renew ne "no" && $auto_renew ne "ok";
2875     }
2876
2877     return ( 0, "auto_renew" ) if $auto_renew eq "ok" && !$override_limit; # 0 if auto-renewal should not succeed
2878
2879     return ( 1, undef );
2880 }
2881
2882 =head2 AddRenewal
2883
2884   &AddRenewal($borrowernumber, $itemnumber, $branch, [$datedue], [$lastreneweddate]);
2885
2886 Renews a loan.
2887
2888 C<$borrowernumber> is the borrower number of the patron who currently
2889 has the item.
2890
2891 C<$itemnumber> is the number of the item to renew.
2892
2893 C<$branch> is the library where the renewal took place (if any).
2894            The library that controls the circ policies for the renewal is retrieved from the issues record.
2895
2896 C<$datedue> can be a DateTime object used to set the due date.
2897
2898 C<$lastreneweddate> is an optional ISO-formatted date used to set issues.lastreneweddate.  If
2899 this parameter is not supplied, lastreneweddate is set to the current date.
2900
2901 C<$skipfinecalc> is an optional boolean. There may be circumstances where, even if the
2902 CalculateFinesOnReturn syspref is enabled, we don't want to calculate fines upon renew,
2903 for example, when we're renewing as a result of a fine being paid (see RenewAccruingItemWhenPaid
2904 syspref)
2905
2906 If C<$datedue> is the empty string, C<&AddRenewal> will calculate the due date automatically
2907 from the book's item type.
2908
2909 =cut
2910
2911 sub AddRenewal {
2912     my $borrowernumber  = shift;
2913     my $itemnumber      = shift or return;
2914     my $branch          = shift;
2915     my $datedue         = shift;
2916     my $lastreneweddate = shift || dt_from_string();
2917     my $skipfinecalc    = shift;
2918
2919     my $item_object   = Koha::Items->find($itemnumber) or return;
2920     my $biblio = $item_object->biblio;
2921     my $issue  = $item_object->checkout;
2922     my $item_unblessed = $item_object->unblessed;
2923
2924     my $dbh = C4::Context->dbh;
2925
2926     return unless $issue;
2927
2928     $borrowernumber ||= $issue->borrowernumber;
2929
2930     if ( defined $datedue && ref $datedue ne 'DateTime' ) {
2931         carp 'Invalid date passed to AddRenewal.';
2932         return;
2933     }
2934
2935     my $patron = Koha::Patrons->find( $borrowernumber ) or return; # FIXME Should do more than just return
2936     my $patron_unblessed = $patron->unblessed;
2937
2938     my $circ_library = Koha::Libraries->find( _GetCircControlBranch($item_unblessed, $patron_unblessed) );
2939
2940     my $schema = Koha::Database->schema;
2941     $schema->txn_do(sub{
2942
2943         if ( !$skipfinecalc && C4::Context->preference('CalculateFinesOnReturn') ) {
2944             _CalculateAndUpdateFine( { issue => $issue, item => $item_unblessed, borrower => $patron_unblessed } );
2945         }
2946         _FixOverduesOnReturn( $borrowernumber, $itemnumber, undef, 'RENEWED' );
2947
2948         # If the due date wasn't specified, calculate it by adding the
2949         # book's loan length to today's date or the current due date
2950         # based on the value of the RenewalPeriodBase syspref.
2951         my $itemtype = $item_object->effective_itemtype;
2952         unless ($datedue) {
2953
2954             $datedue = (C4::Context->preference('RenewalPeriodBase') eq 'date_due') ?
2955                                             dt_from_string( $issue->date_due, 'sql' ) :
2956                                             dt_from_string();
2957             $datedue =  CalcDateDue($datedue, $itemtype, $circ_library->branchcode, $patron_unblessed, 'is a renewal');
2958         }
2959
2960         my $fees = Koha::Charges::Fees->new(
2961             {
2962                 patron    => $patron,
2963                 library   => $circ_library,
2964                 item      => $item_object,
2965                 from_date => dt_from_string( $issue->date_due, 'sql' ),
2966                 to_date   => dt_from_string($datedue),
2967             }
2968         );
2969
2970         # Update the issues record to have the new due date, and a new count
2971         # of how many times it has been renewed.
2972         my $renews = ( $issue->renewals || 0 ) + 1;
2973         my $sth = $dbh->prepare("UPDATE issues SET date_due = ?, renewals = ?, lastreneweddate = ?
2974                                 WHERE borrowernumber=?
2975                                 AND itemnumber=?"
2976         );
2977
2978         $sth->execute( $datedue->strftime('%Y-%m-%d %H:%M'), $renews, $lastreneweddate, $borrowernumber, $itemnumber );
2979
2980         # Update the renewal count on the item, and tell zebra to reindex
2981         $renews = ( $item_object->renewals || 0 ) + 1;
2982         $item_object->renewals($renews);
2983         $item_object->onloan($datedue);
2984         $item_object->store({ log_action => 0 });
2985
2986         # Charge a new rental fee, if applicable
2987         my ( $charge, $type ) = GetIssuingCharges( $itemnumber, $borrowernumber );
2988         if ( $charge > 0 ) {
2989             AddIssuingCharge($issue, $charge, 'RENT_RENEW');
2990         }
2991
2992         # Charge a new accumulate rental fee, if applicable
2993         my $itemtype_object = Koha::ItemTypes->find( $itemtype );
2994         if ( $itemtype_object ) {
2995             my $accumulate_charge = $fees->accumulate_rentalcharge();
2996             if ( $accumulate_charge > 0 ) {
2997                 AddIssuingCharge( $issue, $accumulate_charge, 'RENT_DAILY_RENEW' )
2998             }
2999             $charge += $accumulate_charge;
3000         }
3001
3002         # Send a renewal slip according to checkout alert preferencei
3003         if ( C4::Context->preference('RenewalSendNotice') eq '1' ) {
3004             my $circulation_alert = 'C4::ItemCirculationAlertPreference';
3005             my %conditions        = (
3006                 branchcode   => $branch,
3007                 categorycode => $patron->categorycode,
3008                 item_type    => $itemtype,
3009                 notification => 'CHECKOUT',
3010             );
3011             if ( $circulation_alert->is_enabled_for( \%conditions ) ) {
3012                 SendCirculationAlert(
3013                     {
3014                         type     => 'RENEWAL',
3015                         item     => $item_unblessed,
3016                         borrower => $patron->unblessed,
3017                         branch   => $branch,
3018                     }
3019                 );
3020             }
3021         }
3022
3023         # Remove any OVERDUES related debarment if the borrower has no overdues
3024         if ( $patron
3025           && $patron->is_debarred
3026           && ! $patron->has_overdues
3027           && @{ GetDebarments({ borrowernumber => $borrowernumber, type => 'OVERDUES' }) }
3028         ) {
3029             DelUniqueDebarment({ borrowernumber => $borrowernumber, type => 'OVERDUES' });
3030         }
3031
3032         # Add the renewal to stats
3033         UpdateStats(
3034             {
3035                 branch         => $item_object->renewal_branchcode({branch => $branch}),
3036                 type           => 'renew',
3037                 amount         => $charge,
3038                 itemnumber     => $itemnumber,
3039                 itemtype       => $itemtype,
3040                 location       => $item_object->location,
3041                 borrowernumber => $borrowernumber,
3042                 ccode          => $item_object->ccode,
3043             }
3044         );
3045
3046         #Log the renewal
3047         logaction("CIRCULATION", "RENEWAL", $borrowernumber, $itemnumber) if C4::Context->preference("RenewalLog");
3048     });
3049
3050     return $datedue;
3051 }
3052
3053 sub GetRenewCount {
3054     # check renewal status
3055     my ( $bornum, $itemno ) = @_;
3056     my $dbh           = C4::Context->dbh;
3057     my $renewcount    = 0;
3058     my $renewsallowed = 0;
3059     my $renewsleft    = 0;
3060
3061     my $patron = Koha::Patrons->find( $bornum );
3062     my $item   = Koha::Items->find($itemno);
3063
3064     return (0, 0, 0) unless $patron or $item; # Wrong call, no renewal allowed
3065
3066     # Look in the issues table for this item, lent to this borrower,
3067     # and not yet returned.
3068
3069     # FIXME - I think this function could be redone to use only one SQL call.
3070     my $sth = $dbh->prepare(
3071         "select * from issues
3072                                 where (borrowernumber = ?)
3073                                 and (itemnumber = ?)"
3074     );
3075     $sth->execute( $bornum, $itemno );
3076     my $data = $sth->fetchrow_hashref;
3077     $renewcount = $data->{'renewals'} if $data->{'renewals'};
3078     # $item and $borrower should be calculated
3079     my $branchcode = _GetCircControlBranch($item->unblessed, $patron->unblessed);
3080
3081     my $rule = Koha::CirculationRules->get_effective_rule(
3082         {
3083             categorycode => $patron->categorycode,
3084             itemtype     => $item->effective_itemtype,
3085             branchcode   => $branchcode,
3086             rule_name    => 'renewalsallowed',
3087         }
3088     );
3089
3090     $renewsallowed = $rule ? $rule->rule_value : 0;
3091     $renewsleft    = $renewsallowed - $renewcount;
3092     if($renewsleft < 0){ $renewsleft = 0; }
3093     return ( $renewcount, $renewsallowed, $renewsleft );
3094 }
3095
3096 =head2 GetSoonestRenewDate
3097
3098   $NoRenewalBeforeThisDate = &GetSoonestRenewDate($borrowernumber, $itemnumber);
3099
3100 Find out the soonest possible renew date of a borrowed item.
3101
3102 C<$borrowernumber> is the borrower number of the patron who currently
3103 has the item on loan.
3104
3105 C<$itemnumber> is the number of the item to renew.
3106
3107 C<$GetSoonestRenewDate> returns the DateTime of the soonest possible
3108 renew date, based on the value "No renewal before" of the applicable
3109 issuing rule. Returns the current date if the item can already be
3110 renewed, and returns undefined if the borrower, loan, or item
3111 cannot be found.
3112
3113 =cut
3114
3115 sub GetSoonestRenewDate {
3116     my ( $borrowernumber, $itemnumber ) = @_;
3117
3118     my $dbh = C4::Context->dbh;
3119
3120     my $item      = Koha::Items->find($itemnumber)      or return;
3121     my $itemissue = $item->checkout or return;
3122
3123     $borrowernumber ||= $itemissue->borrowernumber;
3124     my $patron = Koha::Patrons->find( $borrowernumber )
3125       or return;
3126
3127     my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
3128     my $issuing_rule = Koha::CirculationRules->get_effective_rules(
3129         {   categorycode => $patron->categorycode,
3130             itemtype     => $item->effective_itemtype,
3131             branchcode   => $branchcode,
3132             rules => [
3133                 'norenewalbefore',
3134                 'lengthunit',
3135             ]
3136         }
3137     );
3138
3139     my $now = dt_from_string;
3140     return $now unless $issuing_rule;
3141
3142     if ( defined $issuing_rule->{norenewalbefore}
3143         and $issuing_rule->{norenewalbefore} ne "" )
3144     {
3145         my $soonestrenewal =
3146           dt_from_string( $itemissue->date_due )->subtract(
3147             $issuing_rule->{lengthunit} => $issuing_rule->{norenewalbefore} );
3148
3149         if ( C4::Context->preference('NoRenewalBeforePrecision') eq 'date'
3150             and $issuing_rule->{lengthunit} eq 'days' )
3151         {
3152             $soonestrenewal->truncate( to => 'day' );
3153         }
3154         return $soonestrenewal if $now < $soonestrenewal;
3155     }
3156     return $now;
3157 }
3158
3159 =head2 GetLatestAutoRenewDate
3160
3161   $NoAutoRenewalAfterThisDate = &GetLatestAutoRenewDate($borrowernumber, $itemnumber);
3162
3163 Find out the latest possible auto renew date of a borrowed item.
3164
3165 C<$borrowernumber> is the borrower number of the patron who currently
3166 has the item on loan.
3167
3168 C<$itemnumber> is the number of the item to renew.
3169
3170 C<$GetLatestAutoRenewDate> returns the DateTime of the latest possible
3171 auto renew date, based on the value "No auto renewal after" and the "No auto
3172 renewal after (hard limit) of the applicable issuing rule.
3173 Returns undef if there is no date specify in the circ rules or if the patron, loan,
3174 or item cannot be found.
3175
3176 =cut
3177
3178 sub GetLatestAutoRenewDate {
3179     my ( $borrowernumber, $itemnumber ) = @_;
3180
3181     my $dbh = C4::Context->dbh;
3182
3183     my $item      = Koha::Items->find($itemnumber)  or return;
3184     my $itemissue = $item->checkout                 or return;
3185
3186     $borrowernumber ||= $itemissue->borrowernumber;
3187     my $patron = Koha::Patrons->find( $borrowernumber )
3188       or return;
3189
3190     my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
3191     my $circulation_rules = Koha::CirculationRules->get_effective_rules(
3192         {
3193             categorycode => $patron->categorycode,
3194             itemtype     => $item->effective_itemtype,
3195             branchcode   => $branchcode,
3196             rules => [
3197                 'no_auto_renewal_after',
3198                 'no_auto_renewal_after_hard_limit',
3199                 'lengthunit',
3200             ]
3201         }
3202     );
3203
3204     return unless $circulation_rules;
3205     return
3206       if ( not $circulation_rules->{no_auto_renewal_after}
3207             or $circulation_rules->{no_auto_renewal_after} eq '' )
3208       and ( not $circulation_rules->{no_auto_renewal_after_hard_limit}
3209              or $circulation_rules->{no_auto_renewal_after_hard_limit} eq '' );
3210
3211     my $maximum_renewal_date;
3212     if ( $circulation_rules->{no_auto_renewal_after} ) {
3213         $maximum_renewal_date = dt_from_string($itemissue->issuedate);
3214         $maximum_renewal_date->add(
3215             $circulation_rules->{lengthunit} => $circulation_rules->{no_auto_renewal_after}
3216         );
3217     }
3218
3219     if ( $circulation_rules->{no_auto_renewal_after_hard_limit} ) {
3220         my $dt = dt_from_string( $circulation_rules->{no_auto_renewal_after_hard_limit} );
3221         $maximum_renewal_date = $dt if not $maximum_renewal_date or $maximum_renewal_date > $dt;
3222     }
3223     return $maximum_renewal_date;
3224 }
3225
3226
3227 =head2 GetIssuingCharges
3228
3229   ($charge, $item_type) = &GetIssuingCharges($itemnumber, $borrowernumber);
3230
3231 Calculate how much it would cost for a given patron to borrow a given
3232 item, including any applicable discounts.
3233
3234 C<$itemnumber> is the item number of item the patron wishes to borrow.
3235
3236 C<$borrowernumber> is the patron's borrower number.
3237
3238 C<&GetIssuingCharges> returns two values: C<$charge> is the rental charge,
3239 and C<$item_type> is the code for the item's item type (e.g., C<VID>
3240 if it's a video).
3241
3242 =cut
3243
3244 sub GetIssuingCharges {
3245
3246     # calculate charges due
3247     my ( $itemnumber, $borrowernumber ) = @_;
3248     my $charge = 0;
3249     my $dbh    = C4::Context->dbh;
3250     my $item_type;
3251
3252     # Get the book's item type and rental charge (via its biblioitem).
3253     my $charge_query = 'SELECT itemtypes.itemtype,rentalcharge FROM items
3254         LEFT JOIN biblioitems ON biblioitems.biblioitemnumber = items.biblioitemnumber';
3255     $charge_query .= (C4::Context->preference('item-level_itypes'))
3256         ? ' LEFT JOIN itemtypes ON items.itype = itemtypes.itemtype'
3257         : ' LEFT JOIN itemtypes ON biblioitems.itemtype = itemtypes.itemtype';
3258
3259     $charge_query .= ' WHERE items.itemnumber =?';
3260
3261     my $sth = $dbh->prepare($charge_query);
3262     $sth->execute($itemnumber);
3263     if ( my $item_data = $sth->fetchrow_hashref ) {
3264         $item_type = $item_data->{itemtype};
3265         $charge    = $item_data->{rentalcharge};
3266         my $branch = C4::Context::mybranch();
3267         my $patron = Koha::Patrons->find( $borrowernumber );
3268         my $discount = _get_discount_from_rule($patron->categorycode, $branch, $item_type);
3269         if ($discount) {
3270             # We may have multiple rules so get the most specific
3271             $charge = ( $charge * ( 100 - $discount ) ) / 100;
3272         }
3273         if ($charge) {
3274             $charge = sprintf '%.2f', $charge; # ensure no fractions of a penny returned
3275         }
3276     }
3277
3278     return ( $charge, $item_type );
3279 }
3280
3281 # Select most appropriate discount rule from those returned
3282 sub _get_discount_from_rule {
3283     my ($categorycode, $branchcode, $itemtype) = @_;
3284
3285     # Set search precedences
3286     my @params = (
3287         {
3288             branchcode   => $branchcode,
3289             itemtype     => $itemtype,
3290             categorycode => $categorycode,
3291         },
3292         {
3293             branchcode   => undef,
3294             categorycode => $categorycode,
3295             itemtype     => $itemtype,
3296         },
3297         {
3298             branchcode   => $branchcode,
3299             categorycode => $categorycode,
3300             itemtype     => undef,
3301         },
3302         {
3303             branchcode   => undef,
3304             categorycode => $categorycode,
3305             itemtype     => undef,
3306         },
3307     );
3308
3309     foreach my $params (@params) {
3310         my $rule = Koha::CirculationRules->search(
3311             {
3312                 rule_name => 'rentaldiscount',
3313                 %$params,
3314             }
3315         )->next();
3316
3317         return $rule->rule_value if $rule;
3318     }
3319
3320     # none of the above
3321     return 0;
3322 }
3323
3324 =head2 AddIssuingCharge
3325
3326   &AddIssuingCharge( $checkout, $charge, $type )
3327
3328 =cut
3329
3330 sub AddIssuingCharge {
3331     my ( $checkout, $charge, $type ) = @_;
3332
3333     # FIXME What if checkout does not exist?
3334
3335     my $account = Koha::Account->new({ patron_id => $checkout->borrowernumber });
3336     my $accountline = $account->add_debit(
3337         {
3338             amount      => $charge,
3339             note        => undef,
3340             user_id     => C4::Context->userenv ? C4::Context->userenv->{'number'} : undef,
3341             library_id  => C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef,
3342             interface   => C4::Context->interface,
3343             type        => $type,
3344             item_id     => $checkout->itemnumber,
3345             issue_id    => $checkout->issue_id,
3346         }
3347     );
3348 }
3349
3350 =head2 GetTransfers
3351
3352   GetTransfers($itemnumber);
3353
3354 =cut
3355
3356 sub GetTransfers {
3357     my ($itemnumber) = @_;
3358
3359     my $dbh = C4::Context->dbh;
3360
3361     my $query = '
3362         SELECT datesent,
3363                frombranch,
3364                tobranch,
3365                branchtransfer_id
3366         FROM branchtransfers
3367         WHERE itemnumber = ?
3368           AND datearrived IS NULL
3369         ';
3370     my $sth = $dbh->prepare($query);
3371     $sth->execute($itemnumber);
3372     my @row = $sth->fetchrow_array();
3373     return @row;
3374 }
3375
3376 =head2 GetTransfersFromTo
3377
3378   @results = GetTransfersFromTo($frombranch,$tobranch);
3379
3380 Returns the list of pending transfers between $from and $to branch
3381
3382 =cut
3383
3384 sub GetTransfersFromTo {
3385     my ( $frombranch, $tobranch ) = @_;
3386     return unless ( $frombranch && $tobranch );
3387     my $dbh   = C4::Context->dbh;
3388     my $query = "
3389         SELECT branchtransfer_id,itemnumber,datesent,frombranch
3390         FROM   branchtransfers
3391         WHERE  frombranch=?
3392           AND  tobranch=?
3393           AND datearrived IS NULL
3394     ";
3395     my $sth = $dbh->prepare($query);
3396     $sth->execute( $frombranch, $tobranch );
3397     my @gettransfers;
3398
3399     while ( my $data = $sth->fetchrow_hashref ) {
3400         push @gettransfers, $data;
3401     }
3402     return (@gettransfers);
3403 }
3404
3405 =head2 DeleteTransfer
3406
3407   &DeleteTransfer($itemnumber);
3408
3409 =cut
3410
3411 sub DeleteTransfer {
3412     my ($itemnumber) = @_;
3413     return unless $itemnumber;
3414     my $dbh          = C4::Context->dbh;
3415     my $sth          = $dbh->prepare(
3416         "DELETE FROM branchtransfers
3417          WHERE itemnumber=?
3418          AND datearrived IS NULL "
3419     );
3420     return $sth->execute($itemnumber);
3421 }
3422
3423 =head2 SendCirculationAlert
3424
3425 Send out a C<check-in> or C<checkout> alert using the messaging system.
3426
3427 B<Parameters>:
3428
3429 =over 4
3430
3431 =item type
3432
3433 Valid values for this parameter are: C<CHECKIN> and C<CHECKOUT>.
3434
3435 =item item
3436
3437 Hashref of information about the item being checked in or out.
3438
3439 =item borrower
3440
3441 Hashref of information about the borrower of the item.
3442
3443 =item branch
3444
3445 The branchcode from where the checkout or check-in took place.
3446
3447 =back
3448
3449 B<Example>:
3450
3451     SendCirculationAlert({
3452         type     => 'CHECKOUT',
3453         item     => $item,
3454         borrower => $borrower,
3455         branch   => $branch,
3456     });
3457
3458 =cut
3459
3460 sub SendCirculationAlert {
3461     my ($opts) = @_;
3462     my ($type, $item, $borrower, $branch) =
3463         ($opts->{type}, $opts->{item}, $opts->{borrower}, $opts->{branch});
3464     my %message_name = (
3465         CHECKIN  => 'Item_Check_in',
3466         CHECKOUT => 'Item_Checkout',
3467         RENEWAL  => 'Item_Checkout',
3468     );
3469     my $borrower_preferences = C4::Members::Messaging::GetMessagingPreferences({
3470         borrowernumber => $borrower->{borrowernumber},
3471         message_name   => $message_name{$type},
3472     });
3473     my $issues_table = ( $type eq 'CHECKOUT' || $type eq 'RENEWAL' ) ? 'issues' : 'old_issues';
3474
3475     my $schema = Koha::Database->new->schema;
3476     my @transports = keys %{ $borrower_preferences->{transports} };
3477
3478     # From the MySQL doc:
3479     # LOCK TABLES is not transaction-safe and implicitly commits any active transaction before attempting to lock the tables.
3480     # If the LOCK/UNLOCK statements are executed from tests, the current transaction will be committed.
3481     # To avoid that we need to guess if this code is execute from tests or not (yes it is a bit hacky)
3482     my $do_not_lock = ( exists $ENV{_} && $ENV{_} =~ m|prove| ) || $ENV{KOHA_TESTING};
3483
3484     for my $mtt (@transports) {
3485         my $letter =  C4::Letters::GetPreparedLetter (
3486             module => 'circulation',
3487             letter_code => $type,
3488             branchcode => $branch,
3489             message_transport_type => $mtt,
3490             lang => $borrower->{lang},
3491             tables => {
3492                 $issues_table => $item->{itemnumber},
3493                 'items'       => $item->{itemnumber},
3494                 'biblio'      => $item->{biblionumber},
3495                 'biblioitems' => $item->{biblionumber},
3496                 'borrowers'   => $borrower,
3497                 'branches'    => $branch,
3498             }
3499         ) or next;
3500
3501         $schema->storage->txn_begin;
3502         C4::Context->dbh->do(q|LOCK TABLE message_queue READ|) unless $do_not_lock;
3503         C4::Context->dbh->do(q|LOCK TABLE message_queue WRITE|) unless $do_not_lock;
3504         my $message = C4::Message->find_last_message($borrower, $type, $mtt);
3505         unless ( $message ) {
3506             C4::Context->dbh->do(q|UNLOCK TABLES|) unless $do_not_lock;
3507             C4::Message->enqueue($letter, $borrower, $mtt);
3508         } else {
3509             $message->append($letter);
3510             $message->update;
3511         }
3512         C4::Context->dbh->do(q|UNLOCK TABLES|) unless $do_not_lock;
3513         $schema->storage->txn_commit;
3514     }
3515
3516     return;
3517 }
3518
3519 =head2 updateWrongTransfer
3520
3521   $items = updateWrongTransfer($itemNumber,$borrowernumber,$waitingAtLibrary,$FromLibrary);
3522
3523 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
3524
3525 =cut
3526
3527 sub updateWrongTransfer {
3528         my ( $itemNumber,$waitingAtLibrary,$FromLibrary ) = @_;
3529         my $dbh = C4::Context->dbh;
3530 # first step validate the actual line of transfert .
3531         my $sth =
3532                 $dbh->prepare(
3533                         "update branchtransfers set datearrived = now(),tobranch=?,comments='wrongtransfer' where itemnumber= ? AND datearrived IS NULL"
3534                 );
3535                 $sth->execute($FromLibrary,$itemNumber);
3536
3537 # second step create a new line of branchtransfer to the right location .
3538         ModItemTransfer($itemNumber, $FromLibrary, $waitingAtLibrary);
3539
3540 #third step changing holdingbranch of item
3541     my $item = Koha::Items->find($itemNumber)->holdingbranch($FromLibrary)->store;
3542 }
3543
3544 =head2 CalcDateDue
3545
3546 $newdatedue = CalcDateDue($startdate,$itemtype,$branchcode,$borrower);
3547
3548 this function calculates the due date given the start date and configured circulation rules,
3549 checking against the holidays calendar as per the 'useDaysMode' syspref.
3550 C<$startdate>   = DateTime object representing start date of loan period (assumed to be today)
3551 C<$itemtype>  = itemtype code of item in question
3552 C<$branch>  = location whose calendar to use
3553 C<$borrower> = Borrower object
3554 C<$isrenewal> = Boolean: is true if we want to calculate the date due for a renewal. Else is false.
3555
3556 =cut
3557
3558 sub CalcDateDue {
3559     my ( $startdate, $itemtype, $branch, $borrower, $isrenewal ) = @_;
3560
3561     $isrenewal ||= 0;
3562
3563     # loanlength now a href
3564     my $loanlength =
3565             GetLoanLength( $borrower->{'categorycode'}, $itemtype, $branch );
3566
3567     my $length_key = ( $isrenewal and defined $loanlength->{renewalperiod} )
3568             ? qq{renewalperiod}
3569             : qq{issuelength};
3570
3571     my $datedue;
3572     if ( $startdate ) {
3573         if (ref $startdate ne 'DateTime' ) {
3574             $datedue = dt_from_string($datedue);
3575         } else {
3576             $datedue = $startdate->clone;
3577         }
3578     } else {
3579         $datedue = dt_from_string()->truncate( to => 'minute' );
3580     }
3581
3582
3583     # calculate the datedue as normal
3584     if ( C4::Context->preference('useDaysMode') eq 'Days' )
3585     {    # ignoring calendar
3586         if ( $loanlength->{lengthunit} eq 'hours' ) {
3587             $datedue->add( hours => $loanlength->{$length_key} );
3588         } else {    # days
3589             $datedue->add( days => $loanlength->{$length_key} );
3590             $datedue->set_hour(23);
3591             $datedue->set_minute(59);
3592         }
3593     } else {
3594         my $dur;
3595         if ($loanlength->{lengthunit} eq 'hours') {
3596             $dur = DateTime::Duration->new( hours => $loanlength->{$length_key});
3597         }
3598         else { # days
3599             $dur = DateTime::Duration->new( days => $loanlength->{$length_key});
3600         }
3601         my $calendar = Koha::Calendar->new( branchcode => $branch );
3602         $datedue = $calendar->addDate( $datedue, $dur, $loanlength->{lengthunit} );
3603         if ($loanlength->{lengthunit} eq 'days') {
3604             $datedue->set_hour(23);
3605             $datedue->set_minute(59);
3606         }
3607     }
3608
3609     # if Hard Due Dates are used, retrieve them and apply as necessary
3610     my ( $hardduedate, $hardduedatecompare ) =
3611       GetHardDueDate( $borrower->{'categorycode'}, $itemtype, $branch );
3612     if ($hardduedate) {    # hardduedates are currently dates
3613         $hardduedate->truncate( to => 'minute' );
3614         $hardduedate->set_hour(23);
3615         $hardduedate->set_minute(59);
3616         my $cmp = DateTime->compare( $hardduedate, $datedue );
3617
3618 # if the calculated due date is after the 'before' Hard Due Date (ceiling), override
3619 # if the calculated date is before the 'after' Hard Due Date (floor), override
3620 # if the hard due date is set to 'exactly', overrride
3621         if ( $hardduedatecompare == 0 || $hardduedatecompare == $cmp ) {
3622             $datedue = $hardduedate->clone;
3623         }
3624
3625         # in all other cases, keep the date due as it is
3626
3627     }
3628
3629     # if ReturnBeforeExpiry ON the datedue can't be after borrower expirydate
3630     if ( C4::Context->preference('ReturnBeforeExpiry') ) {
3631         my $expiry_dt = dt_from_string( $borrower->{dateexpiry}, 'iso', 'floating');
3632         if( $expiry_dt ) { #skip empty expiry date..
3633             $expiry_dt->set( hour => 23, minute => 59);
3634             my $d1= $datedue->clone->set_time_zone('floating');
3635             if ( DateTime->compare( $d1, $expiry_dt ) == 1 ) {
3636                 $datedue = $expiry_dt->clone->set_time_zone( C4::Context->tz );
3637             }
3638         }
3639         if ( C4::Context->preference('useDaysMode') ne 'Days' ) {
3640           my $calendar = Koha::Calendar->new( branchcode => $branch );
3641           if ( $calendar->is_holiday($datedue) ) {
3642               # Don't return on a closed day
3643               $datedue = $calendar->prev_open_days( $datedue, 1 );
3644           }
3645         }
3646     }
3647
3648     return $datedue;
3649 }
3650
3651
3652 sub CheckValidBarcode{
3653 my ($barcode) = @_;
3654 my $dbh = C4::Context->dbh;
3655 my $query=qq|SELECT count(*)
3656              FROM items
3657              WHERE barcode=?
3658             |;
3659 my $sth = $dbh->prepare($query);
3660 $sth->execute($barcode);
3661 my $exist=$sth->fetchrow ;
3662 return $exist;
3663 }
3664
3665 =head2 IsBranchTransferAllowed
3666
3667   $allowed = IsBranchTransferAllowed( $toBranch, $fromBranch, $code );
3668
3669 Code is either an itemtype or collection doe depending on the pref BranchTransferLimitsType
3670
3671 Deprecated in favor of Koha::Item::Transfer::Limits->find/search and
3672 Koha::Item->can_be_transferred.
3673
3674 =cut
3675
3676 sub IsBranchTransferAllowed {
3677         my ( $toBranch, $fromBranch, $code ) = @_;
3678
3679         if ( $toBranch eq $fromBranch ) { return 1; } ## Short circuit for speed.
3680
3681         my $limitType = C4::Context->preference("BranchTransferLimitsType");
3682         my $dbh = C4::Context->dbh;
3683
3684         my $sth = $dbh->prepare("SELECT * FROM branch_transfer_limits WHERE toBranch = ? AND fromBranch = ? AND $limitType = ?");
3685         $sth->execute( $toBranch, $fromBranch, $code );
3686         my $limit = $sth->fetchrow_hashref();
3687
3688         ## If a row is found, then that combination is not allowed, if no matching row is found, then the combination *is allowed*
3689         if ( $limit->{'limitId'} ) {
3690                 return 0;
3691         } else {
3692                 return 1;
3693         }
3694 }
3695
3696 =head2 CreateBranchTransferLimit
3697
3698   CreateBranchTransferLimit( $toBranch, $fromBranch, $code );
3699
3700 $code is either itemtype or collection code depending on what the pref BranchTransferLimitsType is set to.
3701
3702 Deprecated in favor of Koha::Item::Transfer::Limit->new.
3703
3704 =cut
3705
3706 sub CreateBranchTransferLimit {
3707    my ( $toBranch, $fromBranch, $code ) = @_;
3708    return unless defined($toBranch) && defined($fromBranch);
3709    my $limitType = C4::Context->preference("BranchTransferLimitsType");
3710
3711    my $dbh = C4::Context->dbh;
3712
3713    my $sth = $dbh->prepare("INSERT INTO branch_transfer_limits ( $limitType, toBranch, fromBranch ) VALUES ( ?, ?, ? )");
3714    return $sth->execute( $code, $toBranch, $fromBranch );
3715 }
3716
3717 =head2 DeleteBranchTransferLimits
3718
3719     my $result = DeleteBranchTransferLimits($frombranch);
3720
3721 Deletes all the library transfer limits for one library.  Returns the
3722 number of limits deleted, 0e0 if no limits were deleted, or undef if
3723 no arguments are supplied.
3724
3725 Deprecated in favor of Koha::Item::Transfer::Limits->search({
3726     fromBranch => $fromBranch
3727     })->delete.
3728
3729 =cut
3730
3731 sub DeleteBranchTransferLimits {
3732     my $branch = shift;
3733     return unless defined $branch;
3734     my $dbh    = C4::Context->dbh;
3735     my $sth    = $dbh->prepare("DELETE FROM branch_transfer_limits WHERE fromBranch = ?");
3736     return $sth->execute($branch);
3737 }
3738
3739 sub ReturnLostItem{
3740     my ( $borrowernumber, $itemnum ) = @_;
3741     MarkIssueReturned( $borrowernumber, $itemnum );
3742 }
3743
3744 =head2 LostItem
3745
3746   LostItem( $itemnumber, $mark_lost_from, $force_mark_returned, [$params] );
3747
3748 The final optional parameter, C<$params>, expected to contain
3749 'skip_record_index' key, which relayed down to Koha::Item/store,
3750 there it prevents calling of ModZebra index_records,
3751 which takes most of the time in batch adds/deletes: index_records better
3752 to be called later in C<additem.pl> after the whole loop.
3753
3754 $params:
3755     skip_record_index => 1|0
3756
3757 =cut
3758
3759 sub LostItem{
3760     my ($itemnumber, $mark_lost_from, $force_mark_returned, $params) = @_;
3761
3762     unless ( $mark_lost_from ) {
3763         # Temporary check to avoid regressions
3764         die q|LostItem called without $mark_lost_from, check the API.|;
3765     }
3766
3767     my $mark_returned;
3768     if ( $force_mark_returned ) {
3769         $mark_returned = 1;
3770     } else {
3771         my $pref = C4::Context->preference('MarkLostItemsAsReturned') // q{};
3772         $mark_returned = ( $pref =~ m|$mark_lost_from| );
3773     }
3774
3775     my $dbh = C4::Context->dbh();
3776     my $sth=$dbh->prepare("SELECT issues.*,items.*,biblio.title
3777                            FROM issues
3778                            JOIN items USING (itemnumber)
3779                            JOIN biblio USING (biblionumber)
3780                            WHERE issues.itemnumber=?");
3781     $sth->execute($itemnumber);
3782     my $issues=$sth->fetchrow_hashref();
3783
3784     # If a borrower lost the item, add a replacement cost to the their record
3785     if ( my $borrowernumber = $issues->{borrowernumber} ){
3786         my $patron = Koha::Patrons->find( $borrowernumber );
3787
3788         my $fix = _FixOverduesOnReturn($borrowernumber, $itemnumber, C4::Context->preference('WhenLostForgiveFine'), 'LOST');
3789         defined($fix) or warn "_FixOverduesOnReturn($borrowernumber, $itemnumber...) failed!";  # zero is OK, check defined
3790
3791         if (C4::Context->preference('WhenLostChargeReplacementFee')){
3792             C4::Accounts::chargelostitem(
3793                 $borrowernumber,
3794                 $itemnumber,
3795                 $issues->{'replacementprice'},
3796                 sprintf( "%s %s %s",
3797                     $issues->{'title'}          || q{},
3798                     $issues->{'barcode'}        || q{},
3799                     $issues->{'itemcallnumber'} || q{},
3800                 ),
3801             );
3802             #FIXME : Should probably have a way to distinguish this from an item that really was returned.
3803             #warn " $issues->{'borrowernumber'}  /  $itemnumber ";
3804         }
3805
3806         MarkIssueReturned($borrowernumber,$itemnumber,undef,$patron->privacy) if $mark_returned;
3807     }
3808
3809     #When item is marked lost automatically cancel its outstanding transfers and set items holdingbranch to the transfer source branch (frombranch)
3810     if (my ( $datesent,$frombranch,$tobranch ) = GetTransfers($itemnumber)) {
3811         Koha::Items->find($itemnumber)->holdingbranch($frombranch)->store({ skip_record_index => $params->{skip_record_index} });
3812     }
3813     my $transferdeleted = DeleteTransfer($itemnumber);
3814 }
3815
3816 sub GetOfflineOperations {
3817     my $dbh = C4::Context->dbh;
3818     my $sth = $dbh->prepare("SELECT * FROM pending_offline_operations WHERE branchcode=? ORDER BY timestamp");
3819     $sth->execute(C4::Context->userenv->{'branch'});
3820     my $results = $sth->fetchall_arrayref({});
3821     return $results;
3822 }
3823
3824 sub GetOfflineOperation {
3825     my $operationid = shift;
3826     return unless $operationid;
3827     my $dbh = C4::Context->dbh;
3828     my $sth = $dbh->prepare("SELECT * FROM pending_offline_operations WHERE operationid=?");
3829     $sth->execute( $operationid );
3830     return $sth->fetchrow_hashref;
3831 }
3832
3833 sub AddOfflineOperation {
3834     my ( $userid, $branchcode, $timestamp, $action, $barcode, $cardnumber, $amount ) = @_;
3835     my $dbh = C4::Context->dbh;
3836     my $sth = $dbh->prepare("INSERT INTO pending_offline_operations (userid, branchcode, timestamp, action, barcode, cardnumber, amount) VALUES(?,?,?,?,?,?,?)");
3837     $sth->execute( $userid, $branchcode, $timestamp, $action, $barcode, $cardnumber, $amount );
3838     return "Added.";
3839 }
3840
3841 sub DeleteOfflineOperation {
3842     my $dbh = C4::Context->dbh;
3843     my $sth = $dbh->prepare("DELETE FROM pending_offline_operations WHERE operationid=?");
3844     $sth->execute( shift );
3845     return "Deleted.";
3846 }
3847
3848 sub ProcessOfflineOperation {
3849     my $operation = shift;
3850
3851     my $report;
3852     if ( $operation->{action} eq 'return' ) {
3853         $report = ProcessOfflineReturn( $operation );
3854     } elsif ( $operation->{action} eq 'issue' ) {
3855         $report = ProcessOfflineIssue( $operation );
3856     } elsif ( $operation->{action} eq 'payment' ) {
3857         $report = ProcessOfflinePayment( $operation );
3858     }
3859
3860     DeleteOfflineOperation( $operation->{operationid} ) if $operation->{operationid};
3861
3862     return $report;
3863 }
3864
3865 sub ProcessOfflineReturn {
3866     my $operation = shift;
3867
3868     my $item = Koha::Items->find({barcode => $operation->{barcode}});
3869
3870     if ( $item ) {
3871         my $itemnumber = $item->itemnumber;
3872         my $issue = GetOpenIssue( $itemnumber );
3873         if ( $issue ) {
3874             my $leave_item_lost = C4::Context->preference("BlockReturnOfLostItems") ? 1 : 0;
3875             ModDateLastSeen( $itemnumber, $leave_item_lost );
3876             MarkIssueReturned(
3877                 $issue->{borrowernumber},
3878                 $itemnumber,
3879                 $operation->{timestamp},
3880             );
3881             $item->renewals(0);
3882             $item->onloan(undef);
3883             $item->store({ log_action => 0 });
3884             return "Success.";
3885         } else {
3886             return "Item not issued.";
3887         }
3888     } else {
3889         return "Item not found.";
3890     }
3891 }
3892
3893 sub ProcessOfflineIssue {
3894     my $operation = shift;
3895
3896     my $patron = Koha::Patrons->find( { cardnumber => $operation->{cardnumber} } );
3897
3898     if ( $patron ) {
3899         my $item = Koha::Items->find({ barcode => $operation->{barcode} });
3900         unless ($item) {
3901             return "Barcode not found.";
3902         }
3903         my $itemnumber = $item->itemnumber;
3904         my $issue = GetOpenIssue( $itemnumber );
3905
3906         if ( $issue and ( $issue->{borrowernumber} ne $patron->borrowernumber ) ) { # Item already issued to another patron mark it returned
3907             MarkIssueReturned(
3908                 $issue->{borrowernumber},
3909                 $itemnumber,
3910                 $operation->{timestamp},
3911             );
3912         }
3913         AddIssue(
3914             $patron->unblessed,
3915             $operation->{'barcode'},
3916             undef,
3917             1,
3918             $operation->{timestamp},
3919             undef,
3920         );
3921         return "Success.";
3922     } else {
3923         return "Borrower not found.";
3924     }
3925 }
3926
3927 sub ProcessOfflinePayment {
3928     my $operation = shift;
3929
3930     my $patron = Koha::Patrons->find({ cardnumber => $operation->{cardnumber} });
3931
3932     $patron->account->pay(
3933         {
3934             amount     => $operation->{amount},
3935             library_id => $operation->{branchcode},
3936             interface  => 'koc'
3937         }
3938     );
3939
3940     return "Success.";
3941 }
3942
3943 =head2 TransferSlip
3944
3945   TransferSlip($user_branch, $itemnumber, $barcode, $to_branch)
3946
3947   Returns letter hash ( see C4::Letters::GetPreparedLetter ) or undef
3948
3949 =cut
3950
3951 sub TransferSlip {
3952     my ($branch, $itemnumber, $barcode, $to_branch) = @_;
3953
3954     my $item =
3955       $itemnumber
3956       ? Koha::Items->find($itemnumber)
3957       : Koha::Items->find( { barcode => $barcode } );
3958
3959     $item or return;
3960
3961     return C4::Letters::GetPreparedLetter (
3962         module => 'circulation',
3963         letter_code => 'TRANSFERSLIP',
3964         branchcode => $branch,
3965         tables => {
3966             'branches'    => $to_branch,
3967             'biblio'      => $item->biblionumber,
3968             'items'       => $item->unblessed,
3969         },
3970     );
3971 }
3972
3973 =head2 CheckIfIssuedToPatron
3974
3975   CheckIfIssuedToPatron($borrowernumber, $biblionumber)
3976
3977   Return 1 if any record item is issued to patron, otherwise return 0
3978
3979 =cut
3980
3981 sub CheckIfIssuedToPatron {
3982     my ($borrowernumber, $biblionumber) = @_;
3983
3984     my $dbh = C4::Context->dbh;
3985     my $query = q|
3986         SELECT COUNT(*) FROM issues
3987         LEFT JOIN items ON items.itemnumber = issues.itemnumber
3988         WHERE items.biblionumber = ?
3989         AND issues.borrowernumber = ?
3990     |;
3991     my $is_issued = $dbh->selectrow_array($query, {}, $biblionumber, $borrowernumber );
3992     return 1 if $is_issued;
3993     return;
3994 }
3995
3996 =head2 IsItemIssued
3997
3998   IsItemIssued( $itemnumber )
3999
4000   Return 1 if the item is on loan, otherwise return 0
4001
4002 =cut
4003
4004 sub IsItemIssued {
4005     my $itemnumber = shift;
4006     my $dbh = C4::Context->dbh;
4007     my $sth = $dbh->prepare(q{
4008         SELECT COUNT(*)
4009         FROM issues
4010         WHERE itemnumber = ?
4011     });
4012     $sth->execute($itemnumber);
4013     return $sth->fetchrow;
4014 }
4015
4016 =head2 GetAgeRestriction
4017
4018   my ($ageRestriction, $daysToAgeRestriction) = GetAgeRestriction($record_restrictions, $borrower);
4019   my ($ageRestriction, $daysToAgeRestriction) = GetAgeRestriction($record_restrictions);
4020
4021   if($daysToAgeRestriction <= 0) { #Borrower is allowed to access this material, as they are older or as old as the agerestriction }
4022   if($daysToAgeRestriction > 0) { #Borrower is this many days from meeting the agerestriction }
4023
4024 @PARAM1 the koha.biblioitems.agerestriction value, like K18, PEGI 13, ...
4025 @PARAM2 a borrower-object with koha.borrowers.dateofbirth. (OPTIONAL)
4026 @RETURNS The age restriction age in years and the days to fulfill the age restriction for the given borrower.
4027          Negative days mean the borrower has gone past the age restriction age.
4028
4029 =cut
4030
4031 sub GetAgeRestriction {
4032     my ($record_restrictions, $borrower) = @_;
4033     my $markers = C4::Context->preference('AgeRestrictionMarker');
4034
4035     return unless $record_restrictions;
4036     # Split $record_restrictions to something like FSK 16 or PEGI 6
4037     my @values = split ' ', uc($record_restrictions);
4038     return unless @values;
4039
4040     # Search first occurrence of one of the markers
4041     my @markers = split /\|/, uc($markers);
4042     return unless @markers;
4043
4044     my $index            = 0;
4045     my $restriction_year = 0;
4046     for my $value (@values) {
4047         $index++;
4048         for my $marker (@markers) {
4049             $marker =~ s/^\s+//;    #remove leading spaces
4050             $marker =~ s/\s+$//;    #remove trailing spaces
4051             if ( $marker eq $value ) {
4052                 if ( $index <= $#values ) {
4053                     $restriction_year += $values[$index];
4054                 }
4055                 last;
4056             }
4057             elsif ( $value =~ /^\Q$marker\E(\d+)$/ ) {
4058
4059                 # Perhaps it is something like "K16" (as in Finland)
4060                 $restriction_year += $1;
4061                 last;
4062             }
4063         }
4064         last if ( $restriction_year > 0 );
4065     }
4066
4067     #Check if the borrower is age restricted for this material and for how long.
4068     if ($restriction_year && $borrower) {
4069         if ( $borrower->{'dateofbirth'} ) {
4070             my @alloweddate = split /-/, $borrower->{'dateofbirth'};
4071             $alloweddate[0] += $restriction_year;
4072
4073             #Prevent runime eror on leap year (invalid date)
4074             if ( ( $alloweddate[1] == 2 ) && ( $alloweddate[2] == 29 ) ) {
4075                 $alloweddate[2] = 28;
4076             }
4077
4078             #Get how many days the borrower has to reach the age restriction
4079             my @Today = split /-/, dt_from_string()->ymd();
4080             my $daysToAgeRestriction = Date_to_Days(@alloweddate) - Date_to_Days(@Today);
4081             #Negative days means the borrower went past the age restriction age
4082             return ($restriction_year, $daysToAgeRestriction);
4083         }
4084     }
4085
4086     return ($restriction_year);
4087 }
4088
4089
4090 =head2 GetPendingOnSiteCheckouts
4091
4092 =cut
4093
4094 sub GetPendingOnSiteCheckouts {
4095     my $dbh = C4::Context->dbh;
4096     return $dbh->selectall_arrayref(q|
4097         SELECT
4098           items.barcode,
4099           items.biblionumber,
4100           items.itemnumber,
4101           items.itemnotes,
4102           items.itemcallnumber,
4103           items.location,
4104           issues.date_due,
4105           issues.branchcode,
4106           issues.date_due < NOW() AS is_overdue,
4107           biblio.author,
4108           biblio.title,
4109           borrowers.firstname,
4110           borrowers.surname,
4111           borrowers.cardnumber,
4112           borrowers.borrowernumber
4113         FROM items
4114         LEFT JOIN issues ON items.itemnumber = issues.itemnumber
4115         LEFT JOIN biblio ON items.biblionumber = biblio.biblionumber
4116         LEFT JOIN borrowers ON issues.borrowernumber = borrowers.borrowernumber
4117         WHERE issues.onsite_checkout = 1
4118     |, { Slice => {} } );
4119 }
4120
4121 sub GetTopIssues {
4122     my ($params) = @_;
4123
4124     my ($count, $branch, $itemtype, $ccode, $newness)
4125         = @$params{qw(count branch itemtype ccode newness)};
4126
4127     my $dbh = C4::Context->dbh;
4128     my $query = q{
4129         SELECT * FROM (
4130         SELECT b.biblionumber, b.title, b.author, bi.itemtype, bi.publishercode,
4131           bi.place, bi.publicationyear, b.copyrightdate, bi.pages, bi.size,
4132           i.ccode, SUM(i.issues) AS count
4133         FROM biblio b
4134         LEFT JOIN items i ON (i.biblionumber = b.biblionumber)
4135         LEFT JOIN biblioitems bi ON (bi.biblionumber = b.biblionumber)
4136     };
4137
4138     my (@where_strs, @where_args);
4139
4140     if ($branch) {
4141         push @where_strs, 'i.homebranch = ?';
4142         push @where_args, $branch;
4143     }
4144     if ($itemtype) {
4145         if (C4::Context->preference('item-level_itypes')){
4146             push @where_strs, 'i.itype = ?';
4147             push @where_args, $itemtype;
4148         } else {
4149             push @where_strs, 'bi.itemtype = ?';
4150             push @where_args, $itemtype;
4151         }
4152     }
4153     if ($ccode) {
4154         push @where_strs, 'i.ccode = ?';
4155         push @where_args, $ccode;
4156     }
4157     if ($newness) {
4158         push @where_strs, 'TO_DAYS(NOW()) - TO_DAYS(b.datecreated) <= ?';
4159         push @where_args, $newness;
4160     }
4161
4162     if (@where_strs) {
4163         $query .= 'WHERE ' . join(' AND ', @where_strs);
4164     }
4165
4166     $query .= q{
4167         GROUP BY b.biblionumber, b.title, b.author, bi.itemtype, bi.publishercode,
4168           bi.place, bi.publicationyear, b.copyrightdate, bi.pages, bi.size,
4169           i.ccode
4170         ORDER BY count DESC
4171     };
4172
4173     $query .= q{ ) xxx WHERE count > 0 };
4174     $count = int($count);
4175     if ($count > 0) {
4176         $query .= "LIMIT $count";
4177     }
4178
4179     my $rows = $dbh->selectall_arrayref($query, { Slice => {} }, @where_args);
4180
4181     return @$rows;
4182 }
4183
4184 sub _CalculateAndUpdateFine {
4185     my ($params) = @_;
4186
4187     my $borrower    = $params->{borrower};
4188     my $item        = $params->{item};
4189     my $issue       = $params->{issue};
4190     my $return_date = $params->{return_date};
4191
4192     unless ($borrower) { carp "No borrower passed in!" && return; }
4193     unless ($item)     { carp "No item passed in!"     && return; }
4194     unless ($issue)    { carp "No issue passed in!"    && return; }
4195
4196     my $datedue = dt_from_string( $issue->date_due );
4197
4198     # we only need to calculate and change the fines if we want to do that on return
4199     # Should be on for hourly loans
4200     my $control = C4::Context->preference('CircControl');
4201     my $control_branchcode =
4202         ( $control eq 'ItemHomeLibrary' ) ? $item->{homebranch}
4203       : ( $control eq 'PatronLibrary' )   ? $borrower->{branchcode}
4204       :                                     $issue->branchcode;
4205
4206     my $date_returned = $return_date ? $return_date : dt_from_string();
4207
4208     my ( $amount, $unitcounttotal, $unitcount  ) =
4209       C4::Overdues::CalcFine( $item, $borrower->{categorycode}, $control_branchcode, $datedue, $date_returned );
4210
4211     if ( C4::Context->preference('finesMode') eq 'production' ) {
4212         if ( $amount > 0 ) {
4213             C4::Overdues::UpdateFine({
4214                 issue_id       => $issue->issue_id,
4215                 itemnumber     => $issue->itemnumber,
4216                 borrowernumber => $issue->borrowernumber,
4217                 amount         => $amount,
4218                 due            => output_pref($datedue),
4219             });
4220         }
4221         elsif ($return_date) {
4222
4223             # Backdated returns may have fines that shouldn't exist,
4224             # so in this case, we need to drop those fines to 0
4225
4226             C4::Overdues::UpdateFine({
4227                 issue_id       => $issue->issue_id,
4228                 itemnumber     => $issue->itemnumber,
4229                 borrowernumber => $issue->borrowernumber,
4230                 amount         => 0,
4231                 due            => output_pref($datedue),
4232             });
4233         }
4234     }
4235 }
4236
4237 sub _item_denied_renewal {
4238     my ($params) = @_;
4239
4240     my $item = $params->{item};
4241     return unless $item;
4242
4243     my $denyingrules = Koha::Config::SysPrefs->find('ItemsDeniedRenewal')->get_yaml_pref_hash();
4244     return unless $denyingrules;
4245     foreach my $field (keys %$denyingrules) {
4246         my $val = $item->$field;
4247         if( !defined $val) {
4248             if ( any { !defined $_ }  @{$denyingrules->{$field}} ){
4249                 return 1;
4250             }
4251         } elsif (any { defined($_) && $val eq $_ } @{$denyingrules->{$field}}) {
4252            # If the results matches the values in the syspref
4253            # We return true if match found
4254             return 1;
4255         }
4256     }
4257     return 0;
4258 }
4259
4260
4261 1;
4262
4263 __END__
4264
4265 =head1 AUTHOR
4266
4267 Koha Development Team <http://koha-community.org/>
4268
4269 =cut