Bug 10694 - Allow arbitrary backdating of returns
[koha.git] / 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 under the
9 # terms of the GNU General Public License as published by the Free Software
10 # Foundation; either version 2 of the License, or (at your option) any later
11 # version.
12 #
13 # Koha is distributed in the hope that it will be useful, but WITHOUT ANY
14 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
15 # A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
16 #
17 # You should have received a copy of the GNU General Public License along
18 # with Koha; if not, write to the Free Software Foundation, Inc.,
19 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20
21
22 use strict;
23 #use warnings; FIXME - Bug 2505
24 use DateTime;
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::Dates;
32 use C4::Dates qw(format_date);
33 use C4::Accounts;
34 use C4::ItemCirculationAlertPreference;
35 use C4::Message;
36 use C4::Debug;
37 use C4::Branch; # GetBranches
38 use C4::Log; # logaction
39 use C4::Koha qw(
40     GetAuthorisedValueByCode
41     GetAuthValCode
42     GetKohaAuthorisedValueLib
43 );
44 use C4::Overdues qw(CalcFine UpdateFine);
45 use Algorithm::CheckDigits;
46
47 use Data::Dumper;
48 use Koha::DateUtils;
49 use Koha::Calendar;
50 use Koha::Borrower::Debarments;
51 use Carp;
52 use Date::Calc qw(
53   Today
54   Today_and_Now
55   Add_Delta_YM
56   Add_Delta_DHMS
57   Date_to_Days
58   Day_of_Week
59   Add_Delta_Days
60 );
61 use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
62
63 BEGIN {
64         require Exporter;
65     $VERSION = 3.07.00.049;     # for version checking
66         @ISA    = qw(Exporter);
67
68         # FIXME subs that should probably be elsewhere
69         push @EXPORT, qw(
70                 &barcodedecode
71         &LostItem
72         &ReturnLostItem
73         );
74
75         # subs to deal with issuing a book
76         push @EXPORT, qw(
77                 &CanBookBeIssued
78                 &CanBookBeRenewed
79                 &AddIssue
80                 &AddRenewal
81                 &GetRenewCount
82         &GetSoonestRenewDate
83                 &GetItemIssue
84                 &GetItemIssues
85                 &GetIssuingCharges
86                 &GetIssuingRule
87         &GetBranchBorrowerCircRule
88         &GetBranchItemRule
89                 &GetBiblioIssues
90                 &GetOpenIssue
91                 &AnonymiseIssueHistory
92         &CheckIfIssuedToPatron
93         &IsItemIssued
94         );
95
96         # subs to deal with returns
97         push @EXPORT, qw(
98                 &AddReturn
99         &MarkIssueReturned
100         );
101
102         # subs to deal with transfers
103         push @EXPORT, qw(
104                 &transferbook
105                 &GetTransfers
106                 &GetTransfersFromTo
107                 &updateWrongTransfer
108                 &DeleteTransfer
109                 &IsBranchTransferAllowed
110                 &CreateBranchTransferLimit
111                 &DeleteBranchTransferLimits
112         &TransferSlip
113         );
114
115     # subs to deal with offline circulation
116     push @EXPORT, qw(
117       &GetOfflineOperations
118       &GetOfflineOperation
119       &AddOfflineOperation
120       &DeleteOfflineOperation
121       &ProcessOfflineOperation
122     );
123 }
124
125 =head1 NAME
126
127 C4::Circulation - Koha circulation module
128
129 =head1 SYNOPSIS
130
131 use C4::Circulation;
132
133 =head1 DESCRIPTION
134
135 The functions in this module deal with circulation, issues, and
136 returns, as well as general information about the library.
137 Also deals with stocktaking.
138
139 =head1 FUNCTIONS
140
141 =head2 barcodedecode
142
143   $str = &barcodedecode($barcode, [$filter]);
144
145 Generic filter function for barcode string.
146 Called on every circ if the System Pref itemBarcodeInputFilter is set.
147 Will do some manipulation of the barcode for systems that deliver a barcode
148 to circulation.pl that differs from the barcode stored for the item.
149 For proper functioning of this filter, calling the function on the 
150 correct barcode string (items.barcode) should return an unaltered barcode.
151
152 The optional $filter argument is to allow for testing or explicit 
153 behavior that ignores the System Pref.  Valid values are the same as the 
154 System Pref options.
155
156 =cut
157
158 # FIXME -- the &decode fcn below should be wrapped into this one.
159 # FIXME -- these plugins should be moved out of Circulation.pm
160 #
161 sub barcodedecode {
162     my ($barcode, $filter) = @_;
163     my $branch = C4::Branch::mybranch();
164     $filter = C4::Context->preference('itemBarcodeInputFilter') unless $filter;
165     $filter or return $barcode;     # ensure filter is defined, else return untouched barcode
166         if ($filter eq 'whitespace') {
167                 $barcode =~ s/\s//g;
168         } elsif ($filter eq 'cuecat') {
169                 chomp($barcode);
170             my @fields = split( /\./, $barcode );
171             my @results = map( decode($_), @fields[ 1 .. $#fields ] );
172             ($#results == 2) and return $results[2];
173         } elsif ($filter eq 'T-prefix') {
174                 if ($barcode =~ /^[Tt](\d)/) {
175                         (defined($1) and $1 eq '0') and return $barcode;
176             $barcode = substr($barcode, 2) + 0;     # FIXME: probably should be substr($barcode, 1)
177                 }
178         return sprintf("T%07d", $barcode);
179         # FIXME: $barcode could be "T1", causing warning: substr outside of string
180         # Why drop the nonzero digit after the T?
181         # Why pass non-digits (or empty string) to "T%07d"?
182         } elsif ($filter eq 'libsuite8') {
183                 unless($barcode =~ m/^($branch)-/i){    #if barcode starts with branch code its in Koha style. Skip it.
184                         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
185                                 $barcode =~ s/^[0]*(\d+)$/$branch-b-$1/i;
186                         }else{
187                                 $barcode =~ s/^(\D+)[0]*(\d+)$/$branch-$1-$2/i;
188                         }
189                 }
190     } elsif ($filter eq 'EAN13') {
191         my $ean = CheckDigits('ean');
192         if ( $ean->is_valid($barcode) ) {
193             #$barcode = sprintf('%013d',$barcode); # this doesn't work on 32-bit systems
194             $barcode = '0' x ( 13 - length($barcode) ) . $barcode;
195         } else {
196             warn "# [$barcode] not valid EAN-13/UPC-A\n";
197         }
198         }
199     return $barcode;    # return barcode, modified or not
200 }
201
202 =head2 decode
203
204   $str = &decode($chunk);
205
206 Decodes a segment of a string emitted by a CueCat barcode scanner and
207 returns it.
208
209 FIXME: Should be replaced with Barcode::Cuecat from CPAN
210 or Javascript based decoding on the client side.
211
212 =cut
213
214 sub decode {
215     my ($encoded) = @_;
216     my $seq =
217       'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-';
218     my @s = map { index( $seq, $_ ); } split( //, $encoded );
219     my $l = ( $#s + 1 ) % 4;
220     if ($l) {
221         if ( $l == 1 ) {
222             # warn "Error: Cuecat decode parsing failed!";
223             return;
224         }
225         $l = 4 - $l;
226         $#s += $l;
227     }
228     my $r = '';
229     while ( $#s >= 0 ) {
230         my $n = ( ( $s[0] << 6 | $s[1] ) << 6 | $s[2] ) << 6 | $s[3];
231         $r .=
232             chr( ( $n >> 16 ) ^ 67 )
233          .chr( ( $n >> 8 & 255 ) ^ 67 )
234          .chr( ( $n & 255 ) ^ 67 );
235         @s = @s[ 4 .. $#s ];
236     }
237     $r = substr( $r, 0, length($r) - $l );
238     return $r;
239 }
240
241 =head2 transferbook
242
243   ($dotransfer, $messages, $iteminformation) = &transferbook($newbranch, 
244                                             $barcode, $ignore_reserves);
245
246 Transfers an item to a new branch. If the item is currently on loan, it is automatically returned before the actual transfer.
247
248 C<$newbranch> is the code for the branch to which the item should be transferred.
249
250 C<$barcode> is the barcode of the item to be transferred.
251
252 If C<$ignore_reserves> is true, C<&transferbook> ignores reserves.
253 Otherwise, if an item is reserved, the transfer fails.
254
255 Returns three values:
256
257 =over
258
259 =item $dotransfer 
260
261 is true if the transfer was successful.
262
263 =item $messages
264
265 is a reference-to-hash which may have any of the following keys:
266
267 =over
268
269 =item C<BadBarcode>
270
271 There is no item in the catalog with the given barcode. The value is C<$barcode>.
272
273 =item C<IsPermanent>
274
275 The item's home branch is permanent. This doesn't prevent the item from being transferred, though. The value is the code of the item's home branch.
276
277 =item C<DestinationEqualsHolding>
278
279 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.
280
281 =item C<WasReturned>
282
283 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.
284
285 =item C<ResFound>
286
287 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>.
288
289 =item C<WasTransferred>
290
291 The item was eligible to be transferred. Barring problems communicating with the database, the transfer should indeed have succeeded. The value should be ignored.
292
293 =back
294
295 =back
296
297 =cut
298
299 sub transferbook {
300     my ( $tbr, $barcode, $ignoreRs ) = @_;
301     my $messages;
302     my $dotransfer      = 1;
303     my $branches        = GetBranches();
304     my $itemnumber = GetItemnumberFromBarcode( $barcode );
305     my $issue      = GetItemIssue($itemnumber);
306     my $biblio = GetBiblioFromItemNumber($itemnumber);
307
308     # bad barcode..
309     if ( not $itemnumber ) {
310         $messages->{'BadBarcode'} = $barcode;
311         $dotransfer = 0;
312     }
313
314     # get branches of book...
315     my $hbr = $biblio->{'homebranch'};
316     my $fbr = $biblio->{'holdingbranch'};
317
318     # if using Branch Transfer Limits
319     if ( C4::Context->preference("UseBranchTransferLimits") == 1 ) {
320         if ( C4::Context->preference("item-level_itypes") && C4::Context->preference("BranchTransferLimitsType") eq 'itemtype' ) {
321             if ( ! IsBranchTransferAllowed( $tbr, $fbr, $biblio->{'itype'} ) ) {
322                 $messages->{'NotAllowed'} = $tbr . "::" . $biblio->{'itype'};
323                 $dotransfer = 0;
324             }
325         } elsif ( ! IsBranchTransferAllowed( $tbr, $fbr, $biblio->{ C4::Context->preference("BranchTransferLimitsType") } ) ) {
326             $messages->{'NotAllowed'} = $tbr . "::" . $biblio->{ C4::Context->preference("BranchTransferLimitsType") };
327             $dotransfer = 0;
328         }
329     }
330
331     # if is permanent...
332     if ( $hbr && $branches->{$hbr}->{'PE'} ) {
333         $messages->{'IsPermanent'} = $hbr;
334         $dotransfer = 0;
335     }
336
337     # can't transfer book if is already there....
338     if ( $fbr eq $tbr ) {
339         $messages->{'DestinationEqualsHolding'} = 1;
340         $dotransfer = 0;
341     }
342
343     # check if it is still issued to someone, return it...
344     if ($issue->{borrowernumber}) {
345         AddReturn( $barcode, $fbr );
346         $messages->{'WasReturned'} = $issue->{borrowernumber};
347     }
348
349     # find reserves.....
350     # That'll save a database query.
351     my ( $resfound, $resrec, undef ) =
352       CheckReserves( $itemnumber );
353     if ( $resfound and not $ignoreRs ) {
354         $resrec->{'ResFound'} = $resfound;
355
356         #         $messages->{'ResFound'} = $resrec;
357         $dotransfer = 1;
358     }
359
360     #actually do the transfer....
361     if ($dotransfer) {
362         ModItemTransfer( $itemnumber, $fbr, $tbr );
363
364         # don't need to update MARC anymore, we do it in batch now
365         $messages->{'WasTransfered'} = 1;
366
367     }
368     ModDateLastSeen( $itemnumber );
369     return ( $dotransfer, $messages, $biblio );
370 }
371
372
373 sub TooMany {
374     my $borrower        = shift;
375     my $biblionumber = shift;
376         my $item                = shift;
377     my $cat_borrower    = $borrower->{'categorycode'};
378     my $dbh             = C4::Context->dbh;
379         my $branch;
380         # Get which branchcode we need
381         $branch = _GetCircControlBranch($item,$borrower);
382         my $type = (C4::Context->preference('item-level_itypes')) 
383                         ? $item->{'itype'}         # item-level
384                         : $item->{'itemtype'};     # biblio-level
385  
386     # given branch, patron category, and item type, determine
387     # applicable issuing rule
388     my $issuing_rule = GetIssuingRule($cat_borrower, $type, $branch);
389
390     # if a rule is found and has a loan limit set, count
391     # how many loans the patron already has that meet that
392     # rule
393     if (defined($issuing_rule) and defined($issuing_rule->{'maxissueqty'})) {
394         my @bind_params;
395         my $count_query = "SELECT COUNT(*) FROM issues
396                            JOIN items USING (itemnumber) ";
397
398         my $rule_itemtype = $issuing_rule->{itemtype};
399         if ($rule_itemtype eq "*") {
400             # matching rule has the default item type, so count only
401             # those existing loans that don't fall under a more
402             # specific rule
403             if (C4::Context->preference('item-level_itypes')) {
404                 $count_query .= " WHERE items.itype NOT IN (
405                                     SELECT itemtype FROM issuingrules
406                                     WHERE branchcode = ?
407                                     AND   (categorycode = ? OR categorycode = ?)
408                                     AND   itemtype <> '*'
409                                   ) ";
410             } else { 
411                 $count_query .= " JOIN  biblioitems USING (biblionumber) 
412                                   WHERE biblioitems.itemtype NOT IN (
413                                     SELECT itemtype FROM issuingrules
414                                     WHERE branchcode = ?
415                                     AND   (categorycode = ? OR categorycode = ?)
416                                     AND   itemtype <> '*'
417                                   ) ";
418             }
419             push @bind_params, $issuing_rule->{branchcode};
420             push @bind_params, $issuing_rule->{categorycode};
421             push @bind_params, $cat_borrower;
422         } else {
423             # rule has specific item type, so count loans of that
424             # specific item type
425             if (C4::Context->preference('item-level_itypes')) {
426                 $count_query .= " WHERE items.itype = ? ";
427             } else { 
428                 $count_query .= " JOIN  biblioitems USING (biblionumber) 
429                                   WHERE biblioitems.itemtype= ? ";
430             }
431             push @bind_params, $type;
432         }
433
434         $count_query .= " AND borrowernumber = ? ";
435         push @bind_params, $borrower->{'borrowernumber'};
436         my $rule_branch = $issuing_rule->{branchcode};
437         if ($rule_branch ne "*") {
438             if (C4::Context->preference('CircControl') eq 'PickupLibrary') {
439                 $count_query .= " AND issues.branchcode = ? ";
440                 push @bind_params, $branch;
441             } elsif (C4::Context->preference('CircControl') eq 'PatronLibrary') {
442                 ; # if branch is the patron's home branch, then count all loans by patron
443             } else {
444                 $count_query .= " AND items.homebranch = ? ";
445                 push @bind_params, $branch;
446             }
447         }
448
449         my $count_sth = $dbh->prepare($count_query);
450         $count_sth->execute(@bind_params);
451         my ($current_loan_count) = $count_sth->fetchrow_array;
452
453         my $max_loans_allowed = $issuing_rule->{'maxissueqty'};
454         if ($current_loan_count >= $max_loans_allowed) {
455             return ($current_loan_count, $max_loans_allowed);
456         }
457     }
458
459     # Now count total loans against the limit for the branch
460     my $branch_borrower_circ_rule = GetBranchBorrowerCircRule($branch, $cat_borrower);
461     if (defined($branch_borrower_circ_rule->{maxissueqty})) {
462         my @bind_params = ();
463         my $branch_count_query = "SELECT COUNT(*) FROM issues
464                                   JOIN items USING (itemnumber)
465                                   WHERE borrowernumber = ? ";
466         push @bind_params, $borrower->{borrowernumber};
467
468         if (C4::Context->preference('CircControl') eq 'PickupLibrary') {
469             $branch_count_query .= " AND issues.branchcode = ? ";
470             push @bind_params, $branch;
471         } elsif (C4::Context->preference('CircControl') eq 'PatronLibrary') {
472             ; # if branch is the patron's home branch, then count all loans by patron
473         } else {
474             $branch_count_query .= " AND items.homebranch = ? ";
475             push @bind_params, $branch;
476         }
477         my $branch_count_sth = $dbh->prepare($branch_count_query);
478         $branch_count_sth->execute(@bind_params);
479         my ($current_loan_count) = $branch_count_sth->fetchrow_array;
480
481         my $max_loans_allowed = $branch_borrower_circ_rule->{maxissueqty};
482         if ($current_loan_count >= $max_loans_allowed) {
483             return ($current_loan_count, $max_loans_allowed);
484         }
485     }
486
487     # OK, the patron can issue !!!
488     return;
489 }
490
491 =head2 itemissues
492
493   @issues = &itemissues($biblioitemnumber, $biblio);
494
495 Looks up information about who has borrowed the bookZ<>(s) with the
496 given biblioitemnumber.
497
498 C<$biblio> is ignored.
499
500 C<&itemissues> returns an array of references-to-hash. The keys
501 include the fields from the C<items> table in the Koha database.
502 Additional keys include:
503
504 =over 4
505
506 =item C<date_due>
507
508 If the item is currently on loan, this gives the due date.
509
510 If the item is not on loan, then this is either "Available" or
511 "Cancelled", if the item has been withdrawn.
512
513 =item C<card>
514
515 If the item is currently on loan, this gives the card number of the
516 patron who currently has the item.
517
518 =item C<timestamp0>, C<timestamp1>, C<timestamp2>
519
520 These give the timestamp for the last three times the item was
521 borrowed.
522
523 =item C<card0>, C<card1>, C<card2>
524
525 The card number of the last three patrons who borrowed this item.
526
527 =item C<borrower0>, C<borrower1>, C<borrower2>
528
529 The borrower number of the last three patrons who borrowed this item.
530
531 =back
532
533 =cut
534
535 #'
536 sub itemissues {
537     my ( $bibitem, $biblio ) = @_;
538     my $dbh = C4::Context->dbh;
539     my $sth =
540       $dbh->prepare("Select * from items where items.biblioitemnumber = ?")
541       || die $dbh->errstr;
542     my $i = 0;
543     my @results;
544
545     $sth->execute($bibitem) || die $sth->errstr;
546
547     while ( my $data = $sth->fetchrow_hashref ) {
548
549         # Find out who currently has this item.
550         # FIXME - Wouldn't it be better to do this as a left join of
551         # some sort? Currently, this code assumes that if
552         # fetchrow_hashref() fails, then the book is on the shelf.
553         # fetchrow_hashref() can fail for any number of reasons (e.g.,
554         # database server crash), not just because no items match the
555         # search criteria.
556         my $sth2 = $dbh->prepare(
557             "SELECT * FROM issues
558                 LEFT JOIN borrowers ON issues.borrowernumber = borrowers.borrowernumber
559                 WHERE itemnumber = ?
560             "
561         );
562
563         $sth2->execute( $data->{'itemnumber'} );
564         if ( my $data2 = $sth2->fetchrow_hashref ) {
565             $data->{'date_due'} = $data2->{'date_due'};
566             $data->{'card'}     = $data2->{'cardnumber'};
567             $data->{'borrower'} = $data2->{'borrowernumber'};
568         }
569         else {
570             $data->{'date_due'} = ($data->{'withdrawn'} eq '1') ? 'Cancelled' : 'Available';
571         }
572
573
574         # Find the last 3 people who borrowed this item.
575         $sth2 = $dbh->prepare(
576             "SELECT * FROM old_issues
577                 LEFT JOIN borrowers ON  issues.borrowernumber = borrowers.borrowernumber
578                 WHERE itemnumber = ?
579                 ORDER BY returndate DESC,timestamp DESC"
580         );
581
582         $sth2->execute( $data->{'itemnumber'} );
583         for ( my $i2 = 0 ; $i2 < 2 ; $i2++ )
584         {    # FIXME : error if there is less than 3 pple borrowing this item
585             if ( my $data2 = $sth2->fetchrow_hashref ) {
586                 $data->{"timestamp$i2"} = $data2->{'timestamp'};
587                 $data->{"card$i2"}      = $data2->{'cardnumber'};
588                 $data->{"borrower$i2"}  = $data2->{'borrowernumber'};
589             }    # if
590         }    # for
591
592         $results[$i] = $data;
593         $i++;
594     }
595
596     return (@results);
597 }
598
599 =head2 CanBookBeIssued
600
601   ( $issuingimpossible, $needsconfirmation ) =  CanBookBeIssued( $borrower, 
602                       $barcode, $duedatespec, $inprocess, $ignore_reserves );
603
604 Check if a book can be issued.
605
606 C<$issuingimpossible> and C<$needsconfirmation> are some hashref.
607
608 =over 4
609
610 =item C<$borrower> hash with borrower informations (from GetMember or GetMemberDetails)
611
612 =item C<$barcode> is the bar code of the book being issued.
613
614 =item C<$duedatespec> is a C4::Dates object.
615
616 =item C<$inprocess> boolean switch
617 =item C<$ignore_reserves> boolean switch
618
619 =back
620
621 Returns :
622
623 =over 4
624
625 =item C<$issuingimpossible> a reference to a hash. It contains reasons why issuing is impossible.
626 Possible values are :
627
628 =back
629
630 =head3 INVALID_DATE 
631
632 sticky due date is invalid
633
634 =head3 GNA
635
636 borrower gone with no address
637
638 =head3 CARD_LOST
639
640 borrower declared it's card lost
641
642 =head3 DEBARRED
643
644 borrower debarred
645
646 =head3 UNKNOWN_BARCODE
647
648 barcode unknown
649
650 =head3 NOT_FOR_LOAN
651
652 item is not for loan
653
654 =head3 WTHDRAWN
655
656 item withdrawn.
657
658 =head3 RESTRICTED
659
660 item is restricted (set by ??)
661
662 C<$needsconfirmation> a reference to a hash. It contains reasons why the loan 
663 could be prevented, but ones that can be overriden by the operator.
664
665 Possible values are :
666
667 =head3 DEBT
668
669 borrower has debts.
670
671 =head3 RENEW_ISSUE
672
673 renewing, not issuing
674
675 =head3 ISSUED_TO_ANOTHER
676
677 issued to someone else.
678
679 =head3 RESERVED
680
681 reserved for someone else.
682
683 =head3 INVALID_DATE
684
685 sticky due date is invalid or due date in the past
686
687 =head3 TOO_MANY
688
689 if the borrower borrows to much things
690
691 =cut
692
693 sub CanBookBeIssued {
694     my ( $borrower, $barcode, $duedate, $inprocess, $ignore_reserves ) = @_;
695     my %needsconfirmation;    # filled with problems that needs confirmations
696     my %issuingimpossible;    # filled with problems that causes the issue to be IMPOSSIBLE
697     my %alerts;               # filled with messages that shouldn't stop issuing, but the librarian should be aware of.
698
699     my $item = GetItem(GetItemnumberFromBarcode( $barcode ));
700     my $issue = GetItemIssue($item->{itemnumber});
701         my $biblioitem = GetBiblioItemData($item->{biblioitemnumber});
702         $item->{'itemtype'}=$item->{'itype'}; 
703     my $dbh             = C4::Context->dbh;
704
705     # MANDATORY CHECKS - unless item exists, nothing else matters
706     unless ( $item->{barcode} ) {
707         $issuingimpossible{UNKNOWN_BARCODE} = 1;
708     }
709         return ( \%issuingimpossible, \%needsconfirmation ) if %issuingimpossible;
710
711     #
712     # DUE DATE is OK ? -- should already have checked.
713     #
714     if ($duedate && ref $duedate ne 'DateTime') {
715         $duedate = dt_from_string($duedate);
716     }
717     my $now = DateTime->now( time_zone => C4::Context->tz() );
718     unless ( $duedate ) {
719         my $issuedate = $now->clone();
720
721         my $branch = _GetCircControlBranch($item,$borrower);
722         my $itype = ( C4::Context->preference('item-level_itypes') ) ? $item->{'itype'} : $biblioitem->{'itemtype'};
723         $duedate = CalcDateDue( $issuedate, $itype, $branch, $borrower );
724
725         # Offline circ calls AddIssue directly, doesn't run through here
726         #  So issuingimpossible should be ok.
727     }
728     if ($duedate) {
729         my $today = $now->clone();
730         $today->truncate( to => 'minute');
731         if (DateTime->compare($duedate,$today) == -1 ) { # duedate cannot be before now
732             $needsconfirmation{INVALID_DATE} = output_pref($duedate);
733         }
734     } else {
735             $issuingimpossible{INVALID_DATE} = output_pref($duedate);
736     }
737
738     #
739     # BORROWER STATUS
740     #
741     if ( $borrower->{'category_type'} eq 'X' && (  $item->{barcode}  )) { 
742         # stats only borrower -- add entry to statistics table, and return issuingimpossible{STATS} = 1  .
743         &UpdateStats(C4::Context->userenv->{'branch'},'localuse','','',$item->{'itemnumber'},$item->{'itemtype'},$borrower->{'borrowernumber'}, undef, $item->{'ccode'});
744         ModDateLastSeen( $item->{'itemnumber'} );
745         return( { STATS => 1 }, {});
746     }
747     if ( $borrower->{flags}->{GNA} ) {
748         $issuingimpossible{GNA} = 1;
749     }
750     if ( $borrower->{flags}->{'LOST'} ) {
751         $issuingimpossible{CARD_LOST} = 1;
752     }
753     if ( $borrower->{flags}->{'DBARRED'} ) {
754         $issuingimpossible{DEBARRED} = 1;
755     }
756     if ( !defined $borrower->{dateexpiry} || $borrower->{'dateexpiry'} eq '0000-00-00') {
757         $issuingimpossible{EXPIRED} = 1;
758     } else {
759         my ($y, $m, $d) =  split /-/,$borrower->{'dateexpiry'};
760         if ($y && $m && $d) { # are we really writing oinvalid dates to borrs
761             my $expiry_dt = DateTime->new(
762                 year => $y,
763                 month => $m,
764                 day   => $d,
765                 time_zone => C4::Context->tz,
766             );
767             $expiry_dt->truncate( to => 'day');
768             my $today = $now->clone()->truncate(to => 'day');
769             if (DateTime->compare($today, $expiry_dt) == 1) {
770                 $issuingimpossible{EXPIRED} = 1;
771             }
772         } else {
773             carp("Invalid expity date in borr");
774             $issuingimpossible{EXPIRED} = 1;
775         }
776     }
777     #
778     # BORROWER STATUS
779     #
780
781     # DEBTS
782     my ($balance, $non_issue_charges, $other_charges) =
783       C4::Members::GetMemberAccountBalance( $borrower->{'borrowernumber'} );
784     my $amountlimit = C4::Context->preference("noissuescharge");
785     my $allowfineoverride = C4::Context->preference("AllowFineOverride");
786     my $allfinesneedoverride = C4::Context->preference("AllFinesNeedOverride");
787     if ( C4::Context->preference("IssuingInProcess") ) {
788         if ( $non_issue_charges > $amountlimit && !$inprocess && !$allowfineoverride) {
789             $issuingimpossible{DEBT} = sprintf( "%.2f", $non_issue_charges );
790         } elsif ( $non_issue_charges > $amountlimit && !$inprocess && $allowfineoverride) {
791             $needsconfirmation{DEBT} = sprintf( "%.2f", $non_issue_charges );
792         } elsif ( $allfinesneedoverride && $non_issue_charges > 0 && $non_issue_charges <= $amountlimit && !$inprocess ) {
793             $needsconfirmation{DEBT} = sprintf( "%.2f", $non_issue_charges );
794         }
795     }
796     else {
797         if ( $non_issue_charges > $amountlimit && $allowfineoverride ) {
798             $needsconfirmation{DEBT} = sprintf( "%.2f", $non_issue_charges );
799         } elsif ( $non_issue_charges > $amountlimit && !$allowfineoverride) {
800             $issuingimpossible{DEBT} = sprintf( "%.2f", $non_issue_charges );
801         } elsif ( $non_issue_charges > 0 && $allfinesneedoverride ) {
802             $needsconfirmation{DEBT} = sprintf( "%.2f", $non_issue_charges );
803         }
804     }
805     if ($balance > 0 && $other_charges > 0) {
806         $alerts{OTHER_CHARGES} = sprintf( "%.2f", $other_charges );
807     }
808
809     my ($blocktype, $count) = C4::Members::IsMemberBlocked($borrower->{'borrowernumber'});
810     if ($blocktype == -1) {
811         ## patron has outstanding overdue loans
812             if ( C4::Context->preference("OverduesBlockCirc") eq 'block'){
813                 $issuingimpossible{USERBLOCKEDOVERDUE} = $count;
814             }
815             elsif ( C4::Context->preference("OverduesBlockCirc") eq 'confirmation'){
816                 $needsconfirmation{USERBLOCKEDOVERDUE} = $count;
817             }
818     } elsif($blocktype == 1) {
819         # patron has accrued fine days
820         $issuingimpossible{USERBLOCKEDREMAINING} = $count;
821     }
822
823 #
824     # JB34 CHECKS IF BORROWERS DONT HAVE ISSUE TOO MANY BOOKS
825     #
826         my ($current_loan_count, $max_loans_allowed) = TooMany( $borrower, $item->{biblionumber}, $item );
827     # if TooMany max_loans_allowed returns 0 the user doesn't have permission to check out this book
828     if (defined $max_loans_allowed && $max_loans_allowed == 0) {
829         $needsconfirmation{PATRON_CANT} = 1;
830     } else {
831         if($max_loans_allowed){
832             if ( C4::Context->preference("AllowTooManyOverride") ) {
833                 $needsconfirmation{TOO_MANY} = 1;
834                 $needsconfirmation{current_loan_count} = $current_loan_count;
835                 $needsconfirmation{max_loans_allowed} = $max_loans_allowed;
836             } else {
837                 $issuingimpossible{TOO_MANY} = 1;
838                 $issuingimpossible{current_loan_count} = $current_loan_count;
839                 $issuingimpossible{max_loans_allowed} = $max_loans_allowed;
840             }
841         }
842     }
843
844     #
845     # ITEM CHECKING
846     #
847     if ( $item->{'notforloan'} )
848     {
849         if(!C4::Context->preference("AllowNotForLoanOverride")){
850             $issuingimpossible{NOT_FOR_LOAN} = 1;
851             $issuingimpossible{item_notforloan} = $item->{'notforloan'};
852         }else{
853             $needsconfirmation{NOT_FOR_LOAN_FORCING} = 1;
854             $needsconfirmation{item_notforloan} = $item->{'notforloan'};
855         }
856     }
857     else {
858         # we have to check itemtypes.notforloan also
859         if (C4::Context->preference('item-level_itypes')){
860             # this should probably be a subroutine
861             my $sth = $dbh->prepare("SELECT notforloan FROM itemtypes WHERE itemtype = ?");
862             $sth->execute($item->{'itemtype'});
863             my $notforloan=$sth->fetchrow_hashref();
864             if ($notforloan->{'notforloan'}) {
865                 if (!C4::Context->preference("AllowNotForLoanOverride")) {
866                     $issuingimpossible{NOT_FOR_LOAN} = 1;
867                     $issuingimpossible{itemtype_notforloan} = $item->{'itype'};
868                 } else {
869                     $needsconfirmation{NOT_FOR_LOAN_FORCING} = 1;
870                     $needsconfirmation{itemtype_notforloan} = $item->{'itype'};
871                 }
872             }
873         }
874         elsif ($biblioitem->{'notforloan'} == 1){
875             if (!C4::Context->preference("AllowNotForLoanOverride")) {
876                 $issuingimpossible{NOT_FOR_LOAN} = 1;
877                 $issuingimpossible{itemtype_notforloan} = $biblioitem->{'itemtype'};
878             } else {
879                 $needsconfirmation{NOT_FOR_LOAN_FORCING} = 1;
880                 $needsconfirmation{itemtype_notforloan} = $biblioitem->{'itemtype'};
881             }
882         }
883     }
884     if ( $item->{'withdrawn'} && $item->{'withdrawn'} > 0 )
885     {
886         $issuingimpossible{WTHDRAWN} = 1;
887     }
888     if (   $item->{'restricted'}
889         && $item->{'restricted'} == 1 )
890     {
891         $issuingimpossible{RESTRICTED} = 1;
892     }
893     if ( $item->{'itemlost'} && C4::Context->preference("IssueLostItem") ne 'nothing' ) {
894         my $code = GetAuthorisedValueByCode( 'LOST', $item->{'itemlost'} );
895         $needsconfirmation{ITEM_LOST} = $code if ( C4::Context->preference("IssueLostItem") eq 'confirm' );
896         $alerts{ITEM_LOST} = $code if ( C4::Context->preference("IssueLostItem") eq 'alert' );
897     }
898     if ( C4::Context->preference("IndependentBranches") ) {
899         my $userenv = C4::Context->userenv;
900         unless ( C4::Context->IsSuperLibrarian() ) {
901             if ( $item->{C4::Context->preference("HomeOrHoldingBranch")} ne $userenv->{branch} ){
902                 $issuingimpossible{ITEMNOTSAMEBRANCH} = 1;
903                 $issuingimpossible{'itemhomebranch'} = $item->{C4::Context->preference("HomeOrHoldingBranch")};
904             }
905             $needsconfirmation{BORRNOTSAMEBRANCH} = GetBranchName( $borrower->{'branchcode'} )
906               if ( $borrower->{'branchcode'} ne $userenv->{branch} );
907         }
908     }
909
910     #
911     # CHECK IF BOOK ALREADY ISSUED TO THIS BORROWER
912     #
913     if ( $issue->{borrowernumber} && $issue->{borrowernumber} eq $borrower->{'borrowernumber'} )
914     {
915
916         # Already issued to current borrower. Ask whether the loan should
917         # be renewed.
918         my ($CanBookBeRenewed,$renewerror) = CanBookBeRenewed(
919             $borrower->{'borrowernumber'},
920             $item->{'itemnumber'}
921         );
922         if ( $CanBookBeRenewed == 0 ) {    # no more renewals allowed
923             $issuingimpossible{NO_MORE_RENEWALS} = 1;
924         }
925         else {
926             $needsconfirmation{RENEW_ISSUE} = 1;
927         }
928     }
929     elsif ($issue->{borrowernumber}) {
930
931         # issued to someone else
932         my $currborinfo =    C4::Members::GetMember( borrowernumber => $issue->{borrowernumber} );
933
934 #        warn "=>.$currborinfo->{'firstname'} $currborinfo->{'surname'} ($currborinfo->{'cardnumber'})";
935         $needsconfirmation{ISSUED_TO_ANOTHER} = 1;
936         $needsconfirmation{issued_firstname} = $currborinfo->{'firstname'};
937         $needsconfirmation{issued_surname} = $currborinfo->{'surname'};
938         $needsconfirmation{issued_cardnumber} = $currborinfo->{'cardnumber'};
939         $needsconfirmation{issued_borrowernumber} = $currborinfo->{'borrowernumber'};
940     }
941
942     unless ( $ignore_reserves ) {
943         # See if the item is on reserve.
944         my ( $restype, $res ) = C4::Reserves::CheckReserves( $item->{'itemnumber'} );
945         if ($restype) {
946             my $resbor = $res->{'borrowernumber'};
947             if ( $resbor ne $borrower->{'borrowernumber'} ) {
948                 my ( $resborrower ) = C4::Members::GetMember( borrowernumber => $resbor );
949                 my $branchname = GetBranchName( $res->{'branchcode'} );
950                 if ( $restype eq "Waiting" )
951                 {
952                     # The item is on reserve and waiting, but has been
953                     # reserved by some other patron.
954                     $needsconfirmation{RESERVE_WAITING} = 1;
955                     $needsconfirmation{'resfirstname'} = $resborrower->{'firstname'};
956                     $needsconfirmation{'ressurname'} = $resborrower->{'surname'};
957                     $needsconfirmation{'rescardnumber'} = $resborrower->{'cardnumber'};
958                     $needsconfirmation{'resborrowernumber'} = $resborrower->{'borrowernumber'};
959                     $needsconfirmation{'resbranchname'} = $branchname;
960                     $needsconfirmation{'reswaitingdate'} = format_date($res->{'waitingdate'});
961                 }
962                 elsif ( $restype eq "Reserved" ) {
963                     # The item is on reserve for someone else.
964                     $needsconfirmation{RESERVED} = 1;
965                     $needsconfirmation{'resfirstname'} = $resborrower->{'firstname'};
966                     $needsconfirmation{'ressurname'} = $resborrower->{'surname'};
967                     $needsconfirmation{'rescardnumber'} = $resborrower->{'cardnumber'};
968                     $needsconfirmation{'resborrowernumber'} = $resborrower->{'borrowernumber'};
969                     $needsconfirmation{'resbranchname'} = $branchname;
970                     $needsconfirmation{'resreservedate'} = format_date($res->{'reservedate'});
971                 }
972             }
973         }
974     }
975
976     ## CHECK AGE RESTRICTION
977     # get $marker from preferences. Could be something like "FSK|PEGI|Alter|Age:"
978     my $markers         = C4::Context->preference('AgeRestrictionMarker');
979     my $bibvalues       = $biblioitem->{'agerestriction'};
980     my $restriction_age = GetAgeRestriction( $bibvalues );
981
982     if ( $restriction_age > 0 ) {
983         if ( $borrower->{'dateofbirth'} ) {
984             my @alloweddate = split /-/, $borrower->{'dateofbirth'};
985             $alloweddate[0] += $restriction_age;
986
987             #Prevent runime eror on leap year (invalid date)
988             if ( ( $alloweddate[1] == 2 ) && ( $alloweddate[2] == 29 ) ) {
989                 $alloweddate[2] = 28;
990             }
991
992             if ( Date_to_Days(Today) < Date_to_Days(@alloweddate) - 1 ) {
993                 if ( C4::Context->preference('AgeRestrictionOverride') ) {
994                     $needsconfirmation{AGE_RESTRICTION} = "$bibvalues";
995                 }
996                 else {
997                     $issuingimpossible{AGE_RESTRICTION} = "$bibvalues";
998                 }
999             }
1000         }
1001     }
1002
1003     ## check for high holds decreasing loan period
1004     my $decrease_loan = C4::Context->preference('decreaseLoanHighHolds');
1005     if ( $decrease_loan && $decrease_loan == 1 ) {
1006         my ( $reserved, $num, $duration, $returndate ) =
1007           checkHighHolds( $item, $borrower );
1008
1009         if ( $num >= C4::Context->preference('decreaseLoanHighHoldsValue') ) {
1010             $needsconfirmation{HIGHHOLDS} = {
1011                 num_holds  => $num,
1012                 duration   => $duration,
1013                 returndate => output_pref($returndate),
1014             };
1015         }
1016     }
1017
1018     if (
1019         !C4::Context->preference('AllowMultipleIssuesOnABiblio') &&
1020         # don't do the multiple loans per bib check if we've
1021         # already determined that we've got a loan on the same item
1022         !$issuingimpossible{NO_MORE_RENEWALS} &&
1023         !$needsconfirmation{RENEW_ISSUE}
1024     ) {
1025         # Check if borrower has already issued an item from the same biblio
1026         # Only if it's not a subscription
1027         my $biblionumber = $item->{biblionumber};
1028         require C4::Serials;
1029         my $is_a_subscription = C4::Serials::CountSubscriptionFromBiblionumber($biblionumber);
1030         unless ($is_a_subscription) {
1031             my $issues = GetIssues( {
1032                 borrowernumber => $borrower->{borrowernumber},
1033                 biblionumber   => $biblionumber,
1034             } );
1035             my @issues = $issues ? @$issues : ();
1036             # if we get here, we don't already have a loan on this item,
1037             # so if there are any loans on this bib, ask for confirmation
1038             if (scalar @issues > 0) {
1039                 $needsconfirmation{BIBLIO_ALREADY_ISSUED} = 1;
1040             }
1041         }
1042     }
1043
1044     return ( \%issuingimpossible, \%needsconfirmation, \%alerts );
1045 }
1046
1047 =head2 CanBookBeReturned
1048
1049   ($returnallowed, $message) = CanBookBeReturned($item, $branch)
1050
1051 Check whether the item can be returned to the provided branch
1052
1053 =over 4
1054
1055 =item C<$item> is a hash of item information as returned from GetItem
1056
1057 =item C<$branch> is the branchcode where the return is taking place
1058
1059 =back
1060
1061 Returns:
1062
1063 =over 4
1064
1065 =item C<$returnallowed> is 0 or 1, corresponding to whether the return is allowed (1) or not (0)
1066
1067 =item C<$message> is the branchcode where the item SHOULD be returned, if the return is not allowed
1068
1069 =back
1070
1071 =cut
1072
1073 sub CanBookBeReturned {
1074   my ($item, $branch) = @_;
1075   my $allowreturntobranch = C4::Context->preference("AllowReturnToBranch") || 'anywhere';
1076
1077   # assume return is allowed to start
1078   my $allowed = 1;
1079   my $message;
1080
1081   # identify all cases where return is forbidden
1082   if ($allowreturntobranch eq 'homebranch' && $branch ne $item->{'homebranch'}) {
1083      $allowed = 0;
1084      $message = $item->{'homebranch'};
1085   } elsif ($allowreturntobranch eq 'holdingbranch' && $branch ne $item->{'holdingbranch'}) {
1086      $allowed = 0;
1087      $message = $item->{'holdingbranch'};
1088   } elsif ($allowreturntobranch eq 'homeorholdingbranch' && $branch ne $item->{'homebranch'} && $branch ne $item->{'holdingbranch'}) {
1089      $allowed = 0;
1090      $message = $item->{'homebranch'}; # FIXME: choice of homebranch is arbitrary
1091   }
1092
1093   return ($allowed, $message);
1094 }
1095
1096 =head2 CheckHighHolds
1097
1098     used when syspref decreaseLoanHighHolds is active. Returns 1 or 0 to define whether the minimum value held in
1099     decreaseLoanHighHoldsValue is exceeded, the total number of outstanding holds, the number of days the loan
1100     has been decreased to (held in syspref decreaseLoanHighHoldsValue), and the new due date
1101
1102 =cut
1103
1104 sub checkHighHolds {
1105     my ( $item, $borrower ) = @_;
1106     my $biblio = GetBiblioFromItemNumber( $item->{itemnumber} );
1107     my $branch = _GetCircControlBranch( $item, $borrower );
1108     my $dbh    = C4::Context->dbh;
1109     my $sth    = $dbh->prepare(
1110 'select count(borrowernumber) as num_holds from reserves where biblionumber=?'
1111     );
1112     $sth->execute( $item->{'biblionumber'} );
1113     my ($holds) = $sth->fetchrow_array;
1114     if ($holds) {
1115         my $issuedate = DateTime->now( time_zone => C4::Context->tz() );
1116
1117         my $calendar = Koha::Calendar->new( branchcode => $branch );
1118
1119         my $itype =
1120           ( C4::Context->preference('item-level_itypes') )
1121           ? $biblio->{'itype'}
1122           : $biblio->{'itemtype'};
1123         my $orig_due =
1124           C4::Circulation::CalcDateDue( $issuedate, $itype, $branch,
1125             $borrower );
1126
1127         my $reduced_datedue =
1128           $calendar->addDate( $issuedate,
1129             C4::Context->preference('decreaseLoanHighHoldsDuration') );
1130
1131         if ( DateTime->compare( $reduced_datedue, $orig_due ) == -1 ) {
1132             return ( 1, $holds,
1133                 C4::Context->preference('decreaseLoanHighHoldsDuration'),
1134                 $reduced_datedue );
1135         }
1136     }
1137     return ( 0, 0, 0, undef );
1138 }
1139
1140 =head2 AddIssue
1141
1142   &AddIssue($borrower, $barcode, [$datedue], [$cancelreserve], [$issuedate])
1143
1144 Issue a book. Does no check, they are done in CanBookBeIssued. If we reach this sub, it means the user confirmed if needed.
1145
1146 =over 4
1147
1148 =item C<$borrower> is a hash with borrower informations (from GetMember or GetMemberDetails).
1149
1150 =item C<$barcode> is the barcode of the item being issued.
1151
1152 =item C<$datedue> is a C4::Dates object for the max date of return, i.e. the date due (optional).
1153 Calculated if empty.
1154
1155 =item C<$cancelreserve> is 1 to override and cancel any pending reserves for the item (optional).
1156
1157 =item C<$issuedate> is the date to issue the item in iso (YYYY-MM-DD) format (optional).
1158 Defaults to today.  Unlike C<$datedue>, NOT a C4::Dates object, unfortunately.
1159
1160 AddIssue does the following things :
1161
1162   - step 01: check that there is a borrowernumber & a barcode provided
1163   - check for RENEWAL (book issued & being issued to the same patron)
1164       - renewal YES = Calculate Charge & renew
1165       - renewal NO  =
1166           * BOOK ACTUALLY ISSUED ? do a return if book is actually issued (but to someone else)
1167           * RESERVE PLACED ?
1168               - fill reserve if reserve to this patron
1169               - cancel reserve or not, otherwise
1170           * TRANSFERT PENDING ?
1171               - complete the transfert
1172           * ISSUE THE BOOK
1173
1174 =back
1175
1176 =cut
1177
1178 sub AddIssue {
1179     my ( $borrower, $barcode, $datedue, $cancelreserve, $issuedate, $sipmode) = @_;
1180     my $dbh = C4::Context->dbh;
1181         my $barcodecheck=CheckValidBarcode($barcode);
1182     if ($datedue && ref $datedue ne 'DateTime') {
1183         $datedue = dt_from_string($datedue);
1184     }
1185     # $issuedate defaults to today.
1186     if ( ! defined $issuedate ) {
1187         $issuedate = DateTime->now(time_zone => C4::Context->tz());
1188     }
1189     else {
1190         if ( ref $issuedate ne 'DateTime') {
1191             $issuedate = dt_from_string($issuedate);
1192
1193         }
1194     }
1195         if ($borrower and $barcode and $barcodecheck ne '0'){#??? wtf
1196                 # find which item we issue
1197                 my $item = GetItem('', $barcode) or return;     # if we don't get an Item, abort.
1198                 my $branch = _GetCircControlBranch($item,$borrower);
1199                 
1200                 # get actual issuing if there is one
1201                 my $actualissue = GetItemIssue( $item->{itemnumber});
1202                 
1203                 # get biblioinformation for this item
1204                 my $biblio = GetBiblioFromItemNumber($item->{itemnumber});
1205                 
1206                 #
1207                 # check if we just renew the issue.
1208                 #
1209                 if ($actualissue->{borrowernumber} eq $borrower->{'borrowernumber'}) {
1210                     $datedue = AddRenewal(
1211                         $borrower->{'borrowernumber'},
1212                         $item->{'itemnumber'},
1213                         $branch,
1214                         $datedue,
1215                         $issuedate, # here interpreted as the renewal date
1216                         );
1217                 }
1218                 else {
1219         # it's NOT a renewal
1220                         if ( $actualissue->{borrowernumber}) {
1221                                 # This book is currently on loan, but not to the person
1222                                 # who wants to borrow it now. mark it returned before issuing to the new borrower
1223                                 AddReturn(
1224                                         $item->{'barcode'},
1225                                         C4::Context->userenv->{'branch'}
1226                                 );
1227                         }
1228
1229             MoveReserve( $item->{'itemnumber'}, $borrower->{'borrowernumber'}, $cancelreserve );
1230                         # Starting process for transfer job (checking transfert and validate it if we have one)
1231             my ($datesent) = GetTransfers($item->{'itemnumber'});
1232             if ($datesent) {
1233         #       updating line of branchtranfert to finish it, and changing the to branch value, implement a comment for visibility of this case (maybe for stats ....)
1234                 my $sth =
1235                     $dbh->prepare(
1236                     "UPDATE branchtransfers 
1237                         SET datearrived = now(),
1238                         tobranch = ?,
1239                         comments = 'Forced branchtransfer'
1240                     WHERE itemnumber= ? AND datearrived IS NULL"
1241                     );
1242                 $sth->execute(C4::Context->userenv->{'branch'},$item->{'itemnumber'});
1243             }
1244
1245         # Record in the database the fact that the book was issued.
1246         my $sth =
1247           $dbh->prepare(
1248                 "INSERT INTO issues
1249                     (borrowernumber, itemnumber,issuedate, date_due, branchcode)
1250                 VALUES (?,?,?,?,?)"
1251           );
1252         unless ($datedue) {
1253             my $itype = ( C4::Context->preference('item-level_itypes') ) ? $biblio->{'itype'} : $biblio->{'itemtype'};
1254             $datedue = CalcDateDue( $issuedate, $itype, $branch, $borrower );
1255
1256         }
1257         $datedue->truncate( to => 'minute');
1258         $sth->execute(
1259             $borrower->{'borrowernumber'},      # borrowernumber
1260             $item->{'itemnumber'},              # itemnumber
1261             $issuedate->strftime('%Y-%m-%d %H:%M:00'), # issuedate
1262             $datedue->strftime('%Y-%m-%d %H:%M:00'),   # date_due
1263             C4::Context->userenv->{'branch'}    # branchcode
1264         );
1265         if ( C4::Context->preference('ReturnToShelvingCart') ) { ## ReturnToShelvingCart is on, anything issued should be taken off the cart.
1266           CartToShelf( $item->{'itemnumber'} );
1267         }
1268         $item->{'issues'}++;
1269         if ( C4::Context->preference('UpdateTotalIssuesOnCirc') ) {
1270             UpdateTotalIssues($item->{'biblionumber'}, 1);
1271         }
1272
1273         ## If item was lost, it has now been found, reverse any list item charges if neccessary.
1274         if ( $item->{'itemlost'} ) {
1275             if ( C4::Context->preference('RefundLostItemFeeOnReturn' ) ) {
1276                 _FixAccountForLostAndReturned( $item->{'itemnumber'}, undef, $item->{'barcode'} );
1277             }
1278         }
1279
1280         ModItem({ issues           => $item->{'issues'},
1281                   holdingbranch    => C4::Context->userenv->{'branch'},
1282                   itemlost         => 0,
1283                   datelastborrowed => DateTime->now(time_zone => C4::Context->tz())->ymd(),
1284                   onloan           => $datedue->ymd(),
1285                 }, $item->{'biblionumber'}, $item->{'itemnumber'});
1286         ModDateLastSeen( $item->{'itemnumber'} );
1287
1288         # If it costs to borrow this book, charge it to the patron's account.
1289         my ( $charge, $itemtype ) = GetIssuingCharges(
1290             $item->{'itemnumber'},
1291             $borrower->{'borrowernumber'}
1292         );
1293         if ( $charge > 0 ) {
1294             AddIssuingCharge(
1295                 $item->{'itemnumber'},
1296                 $borrower->{'borrowernumber'}, $charge
1297             );
1298             $item->{'charge'} = $charge;
1299         }
1300
1301         # Record the fact that this book was issued.
1302         &UpdateStats(
1303             C4::Context->userenv->{'branch'},
1304             'issue', $charge,
1305             ($sipmode ? "SIP-$sipmode" : ''), $item->{'itemnumber'},
1306             $item->{'itype'}, $borrower->{'borrowernumber'}, undef, $item->{'ccode'}
1307         );
1308
1309         # Send a checkout slip.
1310         my $circulation_alert = 'C4::ItemCirculationAlertPreference';
1311         my %conditions = (
1312             branchcode   => $branch,
1313             categorycode => $borrower->{categorycode},
1314             item_type    => $item->{itype},
1315             notification => 'CHECKOUT',
1316         );
1317         if ($circulation_alert->is_enabled_for(\%conditions)) {
1318             SendCirculationAlert({
1319                 type     => 'CHECKOUT',
1320                 item     => $item,
1321                 borrower => $borrower,
1322                 branch   => $branch,
1323             });
1324         }
1325     }
1326
1327     logaction("CIRCULATION", "ISSUE", $borrower->{'borrowernumber'}, $biblio->{'itemnumber'})
1328         if C4::Context->preference("IssueLog");
1329   }
1330   return ($datedue);    # not necessarily the same as when it came in!
1331 }
1332
1333 =head2 GetLoanLength
1334
1335   my $loanlength = &GetLoanLength($borrowertype,$itemtype,branchcode)
1336
1337 Get loan length for an itemtype, a borrower type and a branch
1338
1339 =cut
1340
1341 sub GetLoanLength {
1342     my ( $borrowertype, $itemtype, $branchcode ) = @_;
1343     my $dbh = C4::Context->dbh;
1344     my $sth = $dbh->prepare(qq{
1345         SELECT issuelength, lengthunit, renewalperiod
1346         FROM issuingrules
1347         WHERE   categorycode=?
1348             AND itemtype=?
1349             AND branchcode=?
1350             AND issuelength IS NOT NULL
1351     });
1352
1353     # try to find issuelength & return the 1st available.
1354     # check with borrowertype, itemtype and branchcode, then without one of those parameters
1355     $sth->execute( $borrowertype, $itemtype, $branchcode );
1356     my $loanlength = $sth->fetchrow_hashref;
1357
1358     return $loanlength
1359       if defined($loanlength) && $loanlength->{issuelength};
1360
1361     $sth->execute( $borrowertype, '*', $branchcode );
1362     $loanlength = $sth->fetchrow_hashref;
1363     return $loanlength
1364       if defined($loanlength) && $loanlength->{issuelength};
1365
1366     $sth->execute( '*', $itemtype, $branchcode );
1367     $loanlength = $sth->fetchrow_hashref;
1368     return $loanlength
1369       if defined($loanlength) && $loanlength->{issuelength};
1370
1371     $sth->execute( '*', '*', $branchcode );
1372     $loanlength = $sth->fetchrow_hashref;
1373     return $loanlength
1374       if defined($loanlength) && $loanlength->{issuelength};
1375
1376     $sth->execute( $borrowertype, $itemtype, '*' );
1377     $loanlength = $sth->fetchrow_hashref;
1378     return $loanlength
1379       if defined($loanlength) && $loanlength->{issuelength};
1380
1381     $sth->execute( $borrowertype, '*', '*' );
1382     $loanlength = $sth->fetchrow_hashref;
1383     return $loanlength
1384       if defined($loanlength) && $loanlength->{issuelength};
1385
1386     $sth->execute( '*', $itemtype, '*' );
1387     $loanlength = $sth->fetchrow_hashref;
1388     return $loanlength
1389       if defined($loanlength) && $loanlength->{issuelength};
1390
1391     $sth->execute( '*', '*', '*' );
1392     $loanlength = $sth->fetchrow_hashref;
1393     return $loanlength
1394       if defined($loanlength) && $loanlength->{issuelength};
1395
1396     # if no rule is set => 21 days (hardcoded)
1397     return {
1398         issuelength => 21,
1399         renewalperiod => 21,
1400         lengthunit => 'days',
1401     };
1402
1403 }
1404
1405
1406 =head2 GetHardDueDate
1407
1408   my ($hardduedate,$hardduedatecompare) = &GetHardDueDate($borrowertype,$itemtype,branchcode)
1409
1410 Get the Hard Due Date and it's comparison for an itemtype, a borrower type and a branch
1411
1412 =cut
1413
1414 sub GetHardDueDate {
1415     my ( $borrowertype, $itemtype, $branchcode ) = @_;
1416
1417     my $rule = GetIssuingRule( $borrowertype, $itemtype, $branchcode );
1418
1419     if ( defined( $rule ) ) {
1420         if ( $rule->{hardduedate} ) {
1421             return (dt_from_string($rule->{hardduedate}, 'iso'),$rule->{hardduedatecompare});
1422         } else {
1423             return (undef, undef);
1424         }
1425     }
1426 }
1427
1428 =head2 GetIssuingRule
1429
1430   my $irule = &GetIssuingRule($borrowertype,$itemtype,branchcode)
1431
1432 FIXME - This is a copy-paste of GetLoanLength
1433 as a stop-gap.  Do not wish to change API for GetLoanLength 
1434 this close to release.
1435
1436 Get the issuing rule for an itemtype, a borrower type and a branch
1437 Returns a hashref from the issuingrules table.
1438
1439 =cut
1440
1441 sub GetIssuingRule {
1442     my ( $borrowertype, $itemtype, $branchcode ) = @_;
1443     my $dbh = C4::Context->dbh;
1444     my $sth =  $dbh->prepare( "select * from issuingrules where categorycode=? and itemtype=? and branchcode=? and issuelength is not null"  );
1445     my $irule;
1446
1447         $sth->execute( $borrowertype, $itemtype, $branchcode );
1448     $irule = $sth->fetchrow_hashref;
1449     return $irule if defined($irule) ;
1450
1451     $sth->execute( $borrowertype, "*", $branchcode );
1452     $irule = $sth->fetchrow_hashref;
1453     return $irule if defined($irule) ;
1454
1455     $sth->execute( "*", $itemtype, $branchcode );
1456     $irule = $sth->fetchrow_hashref;
1457     return $irule if defined($irule) ;
1458
1459     $sth->execute( "*", "*", $branchcode );
1460     $irule = $sth->fetchrow_hashref;
1461     return $irule if defined($irule) ;
1462
1463     $sth->execute( $borrowertype, $itemtype, "*" );
1464     $irule = $sth->fetchrow_hashref;
1465     return $irule if defined($irule) ;
1466
1467     $sth->execute( $borrowertype, "*", "*" );
1468     $irule = $sth->fetchrow_hashref;
1469     return $irule if defined($irule) ;
1470
1471     $sth->execute( "*", $itemtype, "*" );
1472     $irule = $sth->fetchrow_hashref;
1473     return $irule if defined($irule) ;
1474
1475     $sth->execute( "*", "*", "*" );
1476     $irule = $sth->fetchrow_hashref;
1477     return $irule if defined($irule) ;
1478
1479     # if no rule matches,
1480     return;
1481 }
1482
1483 =head2 GetBranchBorrowerCircRule
1484
1485   my $branch_cat_rule = GetBranchBorrowerCircRule($branchcode, $categorycode);
1486
1487 Retrieves circulation rule attributes that apply to the given
1488 branch and patron category, regardless of item type.  
1489 The return value is a hashref containing the following key:
1490
1491 maxissueqty - maximum number of loans that a
1492 patron of the given category can have at the given
1493 branch.  If the value is undef, no limit.
1494
1495 This will first check for a specific branch and
1496 category match from branch_borrower_circ_rules. 
1497
1498 If no rule is found, it will then check default_branch_circ_rules
1499 (same branch, default category).  If no rule is found,
1500 it will then check default_borrower_circ_rules (default 
1501 branch, same category), then failing that, default_circ_rules
1502 (default branch, default category).
1503
1504 If no rule has been found in the database, it will default to
1505 the buillt in rule:
1506
1507 maxissueqty - undef
1508
1509 C<$branchcode> and C<$categorycode> should contain the
1510 literal branch code and patron category code, respectively - no
1511 wildcards.
1512
1513 =cut
1514
1515 sub GetBranchBorrowerCircRule {
1516     my $branchcode = shift;
1517     my $categorycode = shift;
1518
1519     my $branch_cat_query = "SELECT maxissueqty
1520                             FROM branch_borrower_circ_rules
1521                             WHERE branchcode = ?
1522                             AND   categorycode = ?";
1523     my $dbh = C4::Context->dbh();
1524     my $sth = $dbh->prepare($branch_cat_query);
1525     $sth->execute($branchcode, $categorycode);
1526     my $result;
1527     if ($result = $sth->fetchrow_hashref()) {
1528         return $result;
1529     }
1530
1531     # try same branch, default borrower category
1532     my $branch_query = "SELECT maxissueqty
1533                         FROM default_branch_circ_rules
1534                         WHERE branchcode = ?";
1535     $sth = $dbh->prepare($branch_query);
1536     $sth->execute($branchcode);
1537     if ($result = $sth->fetchrow_hashref()) {
1538         return $result;
1539     }
1540
1541     # try default branch, same borrower category
1542     my $category_query = "SELECT maxissueqty
1543                           FROM default_borrower_circ_rules
1544                           WHERE categorycode = ?";
1545     $sth = $dbh->prepare($category_query);
1546     $sth->execute($categorycode);
1547     if ($result = $sth->fetchrow_hashref()) {
1548         return $result;
1549     }
1550   
1551     # try default branch, default borrower category
1552     my $default_query = "SELECT maxissueqty
1553                           FROM default_circ_rules";
1554     $sth = $dbh->prepare($default_query);
1555     $sth->execute();
1556     if ($result = $sth->fetchrow_hashref()) {
1557         return $result;
1558     }
1559     
1560     # built-in default circulation rule
1561     return {
1562         maxissueqty => undef,
1563     };
1564 }
1565
1566 =head2 GetBranchItemRule
1567
1568   my $branch_item_rule = GetBranchItemRule($branchcode, $itemtype);
1569
1570 Retrieves circulation rule attributes that apply to the given
1571 branch and item type, regardless of patron category.
1572
1573 The return value is a hashref containing the following keys:
1574
1575 holdallowed => Hold policy for this branch and itemtype. Possible values:
1576   0: No holds allowed.
1577   1: Holds allowed only by patrons that have the same homebranch as the item.
1578   2: Holds allowed from any patron.
1579
1580 returnbranch => branch to which to return item.  Possible values:
1581   noreturn: do not return, let item remain where checked in (floating collections)
1582   homebranch: return to item's home branch
1583
1584 This searches branchitemrules in the following order:
1585
1586   * Same branchcode and itemtype
1587   * Same branchcode, itemtype '*'
1588   * branchcode '*', same itemtype
1589   * branchcode and itemtype '*'
1590
1591 Neither C<$branchcode> nor C<$itemtype> should be '*'.
1592
1593 =cut
1594
1595 sub GetBranchItemRule {
1596     my ( $branchcode, $itemtype ) = @_;
1597     my $dbh = C4::Context->dbh();
1598     my $result = {};
1599
1600     my @attempts = (
1601         ['SELECT holdallowed, returnbranch
1602             FROM branch_item_rules
1603             WHERE branchcode = ?
1604               AND itemtype = ?', $branchcode, $itemtype],
1605         ['SELECT holdallowed, returnbranch
1606             FROM default_branch_circ_rules
1607             WHERE branchcode = ?', $branchcode],
1608         ['SELECT holdallowed, returnbranch
1609             FROM default_branch_item_rules
1610             WHERE itemtype = ?', $itemtype],
1611         ['SELECT holdallowed, returnbranch
1612             FROM default_circ_rules'],
1613     );
1614
1615     foreach my $attempt (@attempts) {
1616         my ($query, @bind_params) = @{$attempt};
1617         my $search_result = $dbh->selectrow_hashref ( $query , {}, @bind_params )
1618           or next;
1619
1620         # Since branch/category and branch/itemtype use the same per-branch
1621         # defaults tables, we have to check that the key we want is set, not
1622         # just that a row was returned
1623         $result->{'holdallowed'}  = $search_result->{'holdallowed'}  unless ( defined $result->{'holdallowed'} );
1624         $result->{'returnbranch'} = $search_result->{'returnbranch'} unless ( defined $result->{'returnbranch'} );
1625     }
1626     
1627     # built-in default circulation rule
1628     $result->{'holdallowed'} = 2 unless ( defined $result->{'holdallowed'} );
1629     $result->{'returnbranch'} = 'homebranch' unless ( defined $result->{'returnbranch'} );
1630
1631     return $result;
1632 }
1633
1634 =head2 AddReturn
1635
1636   ($doreturn, $messages, $iteminformation, $borrower) =
1637       &AddReturn($barcode, $branch, $exemptfine, $dropbox, $returndate);
1638
1639 Returns a book.
1640
1641 =over 4
1642
1643 =item C<$barcode> is the bar code of the book being returned.
1644
1645 =item C<$branch> is the code of the branch where the book is being returned.
1646
1647 =item C<$exemptfine> indicates that overdue charges for the item will be
1648 removed.
1649
1650 =item C<$dropbox> indicates that the check-in date is assumed to be
1651 yesterday, or the last non-holiday as defined in C4::Calendar .  If
1652 overdue charges are applied and C<$dropbox> is true, the last charge
1653 will be removed.  This assumes that the fines accrual script has run
1654 for _today_.
1655
1656 =item C<$return_date> allows the default return date to be overridden
1657 by the given return date.
1658
1659 =back
1660
1661 C<&AddReturn> returns a list of four items:
1662
1663 C<$doreturn> is true iff the return succeeded.
1664
1665 C<$messages> is a reference-to-hash giving feedback on the operation.
1666 The keys of the hash are:
1667
1668 =over 4
1669
1670 =item C<BadBarcode>
1671
1672 No item with this barcode exists. The value is C<$barcode>.
1673
1674 =item C<NotIssued>
1675
1676 The book is not currently on loan. The value is C<$barcode>.
1677
1678 =item C<IsPermanent>
1679
1680 The book's home branch is a permanent collection. If you have borrowed
1681 this book, you are not allowed to return it. The value is the code for
1682 the book's home branch.
1683
1684 =item C<withdrawn>
1685
1686 This book has been withdrawn/cancelled. The value should be ignored.
1687
1688 =item C<Wrongbranch>
1689
1690 This book has was returned to the wrong branch.  The value is a hashref
1691 so that C<$messages->{Wrongbranch}->{Wrongbranch}> and C<$messages->{Wrongbranch}->{Rightbranch}>
1692 contain the branchcode of the incorrect and correct return library, respectively.
1693
1694 =item C<ResFound>
1695
1696 The item was reserved. The value is a reference-to-hash whose keys are
1697 fields from the reserves table of the Koha database, and
1698 C<biblioitemnumber>. It also has the key C<ResFound>, whose value is
1699 either C<Waiting>, C<Reserved>, or 0.
1700
1701 =back
1702
1703 C<$iteminformation> is a reference-to-hash, giving information about the
1704 returned item from the issues table.
1705
1706 C<$borrower> is a reference-to-hash, giving information about the
1707 patron who last borrowed the book.
1708
1709 =cut
1710
1711 sub AddReturn {
1712     my ( $barcode, $branch, $exemptfine, $dropbox, $return_date ) = @_;
1713
1714     if ($branch and not GetBranchDetail($branch)) {
1715         warn "AddReturn error: branch '$branch' not found.  Reverting to " . C4::Context->userenv->{'branch'};
1716         undef $branch;
1717     }
1718     $branch = C4::Context->userenv->{'branch'} unless $branch;  # we trust userenv to be a safe fallback/default
1719     my $messages;
1720     my $borrower;
1721     my $biblio;
1722     my $doreturn       = 1;
1723     my $validTransfert = 0;
1724     my $stat_type = 'return';    
1725
1726     # get information on item
1727     my $itemnumber = GetItemnumberFromBarcode( $barcode );
1728     unless ($itemnumber) {
1729         return (0, { BadBarcode => $barcode }); # no barcode means no item or borrower.  bail out.
1730     }
1731     my $issue  = GetItemIssue($itemnumber);
1732 #   warn Dumper($iteminformation);
1733     if ($issue and $issue->{borrowernumber}) {
1734         $borrower = C4::Members::GetMemberDetails($issue->{borrowernumber})
1735             or die "Data inconsistency: barcode $barcode (itemnumber:$itemnumber) claims to be issued to non-existant borrowernumber '$issue->{borrowernumber}'\n"
1736                 . Dumper($issue) . "\n";
1737     } else {
1738         $messages->{'NotIssued'} = $barcode;
1739         # even though item is not on loan, it may still be transferred;  therefore, get current branch info
1740         $doreturn = 0;
1741         # No issue, no borrowernumber.  ONLY if $doreturn, *might* you have a $borrower later.
1742         # Record this as a local use, instead of a return, if the RecordLocalUseOnReturn is on
1743         if (C4::Context->preference("RecordLocalUseOnReturn")) {
1744            $messages->{'LocalUse'} = 1;
1745            $stat_type = 'localuse';
1746         }
1747     }
1748
1749     my $item = GetItem($itemnumber) or die "GetItem($itemnumber) failed";
1750         # full item data, but no borrowernumber or checkout info (no issue)
1751         # we know GetItem should work because GetItemnumberFromBarcode worked
1752     my $hbr      = GetBranchItemRule($item->{'homebranch'}, $item->{'itype'})->{'returnbranch'} || "homebranch";
1753         # get the proper branch to which to return the item
1754     $hbr = $item->{$hbr} || $branch ;
1755         # if $hbr was "noreturn" or any other non-item table value, then it should 'float' (i.e. stay at this branch)
1756
1757     my $borrowernumber = $borrower->{'borrowernumber'} || undef;    # we don't know if we had a borrower or not
1758
1759     # check if the book is in a permanent collection....
1760     # FIXME -- This 'PE' attribute is largely undocumented.  afaict, there's no user interface that reflects this functionality.
1761     if ( $hbr ) {
1762         my $branches = GetBranches();    # a potentially expensive call for a non-feature.
1763         $branches->{$hbr}->{PE} and $messages->{'IsPermanent'} = $hbr;
1764     }
1765
1766     # check if the return is allowed at this branch
1767     my ($returnallowed, $message) = CanBookBeReturned($item, $branch);
1768     unless ($returnallowed){
1769         $messages->{'Wrongbranch'} = {
1770             Wrongbranch => $branch,
1771             Rightbranch => $message
1772         };
1773         $doreturn = 0;
1774         return ( $doreturn, $messages, $issue, $borrower );
1775     }
1776
1777     if ( $item->{'withdrawn'} ) { # book has been cancelled
1778         $messages->{'withdrawn'} = 1;
1779         $doreturn = 0 if C4::Context->preference("BlockReturnOfWithdrawnItems");
1780     }
1781
1782     # case of a return of document (deal with issues and holdingbranch)
1783     my $today = DateTime->now( time_zone => C4::Context->tz() );
1784     if ($doreturn) {
1785         my $datedue = $issue->{date_due};
1786         $borrower or warn "AddReturn without current borrower";
1787                 my $circControlBranch;
1788         if ($dropbox) {
1789             # define circControlBranch only if dropbox mode is set
1790             # don't allow dropbox mode to create an invalid entry in issues (issuedate > today)
1791             # FIXME: check issuedate > returndate, factoring in holidays
1792             #$circControlBranch = _GetCircControlBranch($item,$borrower) unless ( $item->{'issuedate'} eq C4::Dates->today('iso') );;
1793             $circControlBranch = _GetCircControlBranch($item,$borrower);
1794             $issue->{'overdue'} = DateTime->compare($issue->{'date_due'}, $today ) == -1 ? 1 : 0;
1795         }
1796
1797         if ($borrowernumber) {
1798             if ( ( C4::Context->preference('CalculateFinesOnReturn') && $issue->{'overdue'} ) || $return_date ) {
1799                 # we only need to calculate and change the fines if we want to do that on return
1800                 # Should be on for hourly loans
1801                 my $control = C4::Context->preference('CircControl');
1802                 my $control_branchcode =
1803                     ( $control eq 'ItemHomeLibrary' ) ? $item->{homebranch}
1804                   : ( $control eq 'PatronLibrary' )   ? $borrower->{branchcode}
1805                   :                                     $issue->{branchcode};
1806
1807                 my $date_returned =
1808                   $return_date ? dt_from_string($return_date) : $today;
1809
1810                 my ( $amount, $type, $unitcounttotal ) =
1811                   C4::Overdues::CalcFine( $item, $borrower->{categorycode},
1812                     $control_branchcode, $datedue, $date_returned );
1813
1814                 $type ||= q{};
1815
1816                 if ( C4::Context->preference('finesMode') eq 'production' ) {
1817                     if ( $amount > 0 ) {
1818                         C4::Overdues::UpdateFine( $issue->{itemnumber},
1819                             $issue->{borrowernumber},
1820                             $amount, $type, output_pref($datedue) );
1821                     }
1822                     elsif ($return_date) {
1823
1824                        # Backdated returns may have fines that shouldn't exist,
1825                        # so in this case, we need to drop those fines to 0
1826
1827                         C4::Overdues::UpdateFine( $issue->{itemnumber},
1828                             $issue->{borrowernumber},
1829                             0, $type, output_pref($datedue) );
1830                     }
1831                 }
1832             }
1833
1834             MarkIssueReturned( $borrowernumber, $item->{'itemnumber'},
1835                 $circControlBranch, $return_date, $borrower->{'privacy'} );
1836
1837             # FIXME is the "= 1" right?  This could be the borrower hash.
1838             $messages->{'WasReturned'} = 1;
1839
1840         }
1841
1842         ModItem({ onloan => undef }, $issue->{'biblionumber'}, $item->{'itemnumber'});
1843     }
1844
1845     # the holdingbranch is updated if the document is returned to another location.
1846     # this is always done regardless of whether the item was on loan or not
1847     if ($item->{'holdingbranch'} ne $branch) {
1848         UpdateHoldingbranch($branch, $item->{'itemnumber'});
1849         $item->{'holdingbranch'} = $branch; # update item data holdingbranch too
1850     }
1851     ModDateLastSeen( $item->{'itemnumber'} );
1852
1853     # check if we have a transfer for this document
1854     my ($datesent,$frombranch,$tobranch) = GetTransfers( $item->{'itemnumber'} );
1855
1856     # if we have a transfer to do, we update the line of transfers with the datearrived
1857     if ($datesent) {
1858         if ( $tobranch eq $branch ) {
1859             my $sth = C4::Context->dbh->prepare(
1860                 "UPDATE branchtransfers SET datearrived = now() WHERE itemnumber= ? AND datearrived IS NULL"
1861             );
1862             $sth->execute( $item->{'itemnumber'} );
1863             # if we have a reservation with valid transfer, we can set it's status to 'W'
1864             ShelfToCart( $item->{'itemnumber'} ) if ( C4::Context->preference("ReturnToShelvingCart") );
1865             C4::Reserves::ModReserveStatus($item->{'itemnumber'}, 'W');
1866         } else {
1867             $messages->{'WrongTransfer'}     = $tobranch;
1868             $messages->{'WrongTransferItem'} = $item->{'itemnumber'};
1869         }
1870         $validTransfert = 1;
1871     } else {
1872         ShelfToCart( $item->{'itemnumber'} ) if ( C4::Context->preference("ReturnToShelvingCart") );
1873     }
1874
1875     # fix up the accounts.....
1876     if ( $item->{'itemlost'} ) {
1877         $messages->{'WasLost'} = 1;
1878
1879         if ( C4::Context->preference('RefundLostItemFeeOnReturn' ) ) {
1880             _FixAccountForLostAndReturned($item->{'itemnumber'}, $borrowernumber, $barcode);    # can tolerate undef $borrowernumber
1881             $messages->{'LostItemFeeRefunded'} = 1;
1882         }
1883     }
1884
1885     # fix up the overdues in accounts...
1886     if ($borrowernumber) {
1887         my $fix = _FixOverduesOnReturn($borrowernumber, $item->{itemnumber}, $exemptfine, $dropbox);
1888         defined($fix) or warn "_FixOverduesOnReturn($borrowernumber, $item->{itemnumber}...) failed!";  # zero is OK, check defined
1889         
1890         if ( $issue->{overdue} && $issue->{date_due} ) {
1891 # fix fine days
1892             my $debardate =
1893               _debar_user_on_return( $borrower, $item, $issue->{date_due}, $today );
1894             $messages->{Debarred} = $debardate if ($debardate);
1895         }
1896     }
1897
1898     # find reserves.....
1899     # if we don't have a reserve with the status W, we launch the Checkreserves routine
1900     my ($resfound, $resrec);
1901     my $lookahead= C4::Context->preference('ConfirmFutureHolds'); #number of days to look for future holds
1902     ($resfound, $resrec, undef) = C4::Reserves::CheckReserves( $item->{'itemnumber'}, undef, $lookahead ) unless ( $item->{'withdrawn'} );
1903     if ($resfound) {
1904           $resrec->{'ResFound'} = $resfound;
1905         $messages->{'ResFound'} = $resrec;
1906     }
1907
1908     # update stats?
1909     # Record the fact that this book was returned.
1910     UpdateStats(
1911         $branch, $stat_type, '0', '',
1912         $item->{'itemnumber'},
1913         $biblio->{'itemtype'},
1914         $borrowernumber, undef, $item->{'ccode'}
1915     );
1916
1917     # Send a check-in slip. # NOTE: borrower may be undef.  probably shouldn't try to send messages then.
1918     my $circulation_alert = 'C4::ItemCirculationAlertPreference';
1919     my %conditions = (
1920         branchcode   => $branch,
1921         categorycode => $borrower->{categorycode},
1922         item_type    => $item->{itype},
1923         notification => 'CHECKIN',
1924     );
1925     if ($doreturn && $circulation_alert->is_enabled_for(\%conditions)) {
1926         SendCirculationAlert({
1927             type     => 'CHECKIN',
1928             item     => $item,
1929             borrower => $borrower,
1930             branch   => $branch,
1931         });
1932     }
1933     
1934     logaction("CIRCULATION", "RETURN", $borrowernumber, $item->{'itemnumber'})
1935         if C4::Context->preference("ReturnLog");
1936     
1937     # Remove any OVERDUES related debarment if the borrower has no overdues
1938     if ( $borrowernumber
1939       && $borrower->{'debarred'}
1940       && C4::Context->preference('AutoRemoveOverduesRestrictions')
1941       && !HasOverdues( $borrowernumber )
1942       && @{ GetDebarments({ borrowernumber => $borrowernumber, type => 'OVERDUES' }) }
1943     ) {
1944         DelUniqueDebarment({ borrowernumber => $borrowernumber, type => 'OVERDUES' });
1945     }
1946
1947     # FIXME: make this comment intelligible.
1948     #adding message if holdingbranch is non equal a userenv branch to return the document to homebranch
1949     #we check, if we don't have reserv or transfert for this document, if not, return it to homebranch .
1950
1951     if (($doreturn or $messages->{'NotIssued'}) and !$resfound and ($branch ne $hbr) and not $messages->{'WrongTransfer'}){
1952         if ( C4::Context->preference("AutomaticItemReturn"    ) or
1953             (C4::Context->preference("UseBranchTransferLimits") and
1954              ! IsBranchTransferAllowed($branch, $hbr, $item->{C4::Context->preference("BranchTransferLimitsType")} )
1955            )) {
1956             $debug and warn sprintf "about to call ModItemTransfer(%s, %s, %s)", $item->{'itemnumber'},$branch, $hbr;
1957             $debug and warn "item: " . Dumper($item);
1958             ModItemTransfer($item->{'itemnumber'}, $branch, $hbr);
1959             $messages->{'WasTransfered'} = 1;
1960         } else {
1961             $messages->{'NeedsTransfer'} = 1;   # TODO: instead of 1, specify branchcode that the transfer SHOULD go to, $item->{homebranch}
1962         }
1963     }
1964     return ( $doreturn, $messages, $issue, $borrower );
1965 }
1966
1967 =head2 MarkIssueReturned
1968
1969   MarkIssueReturned($borrowernumber, $itemnumber, $dropbox_branch, $returndate, $privacy);
1970
1971 Unconditionally marks an issue as being returned by
1972 moving the C<issues> row to C<old_issues> and
1973 setting C<returndate> to the current date, or
1974 the last non-holiday date of the branccode specified in
1975 C<dropbox_branch> .  Assumes you've already checked that 
1976 it's safe to do this, i.e. last non-holiday > issuedate.
1977
1978 if C<$returndate> is specified (in iso format), it is used as the date
1979 of the return. It is ignored when a dropbox_branch is passed in.
1980
1981 C<$privacy> contains the privacy parameter. If the patron has set privacy to 2,
1982 the old_issue is immediately anonymised
1983
1984 Ideally, this function would be internal to C<C4::Circulation>,
1985 not exported, but it is currently needed by one 
1986 routine in C<C4::Accounts>.
1987
1988 =cut
1989
1990 sub MarkIssueReturned {
1991     my ( $borrowernumber, $itemnumber, $dropbox_branch, $returndate, $privacy ) = @_;
1992
1993     my $dbh   = C4::Context->dbh;
1994     my $query = 'UPDATE issues SET returndate=';
1995     my @bind;
1996     if ($dropbox_branch) {
1997         my $calendar = Koha::Calendar->new( branchcode => $dropbox_branch );
1998         my $dropboxdate = $calendar->addDate( DateTime->now( time_zone => C4::Context->tz), -1 );
1999         $query .= ' ? ';
2000         push @bind, $dropboxdate->strftime('%Y-%m-%d %H:%M');
2001     } elsif ($returndate) {
2002         $query .= ' ? ';
2003         push @bind, $returndate;
2004     } else {
2005         $query .= ' now() ';
2006     }
2007     $query .= ' WHERE  borrowernumber = ?  AND itemnumber = ?';
2008     push @bind, $borrowernumber, $itemnumber;
2009     # FIXME transaction
2010     my $sth_upd  = $dbh->prepare($query);
2011     $sth_upd->execute(@bind);
2012     my $sth_copy = $dbh->prepare('INSERT INTO old_issues SELECT * FROM issues
2013                                   WHERE borrowernumber = ?
2014                                   AND itemnumber = ?');
2015     $sth_copy->execute($borrowernumber, $itemnumber);
2016     # anonymise patron checkout immediately if $privacy set to 2 and AnonymousPatron is set to a valid borrowernumber
2017     if ( $privacy == 2) {
2018         # The default of 0 does not work due to foreign key constraints
2019         # The anonymisation will fail quietly if AnonymousPatron is not a valid entry
2020         # FIXME the above is unacceptable - bug 9942 relates
2021         my $anonymouspatron = (C4::Context->preference('AnonymousPatron')) ? C4::Context->preference('AnonymousPatron') : 0;
2022         my $sth_ano = $dbh->prepare("UPDATE old_issues SET borrowernumber=?
2023                                   WHERE borrowernumber = ?
2024                                   AND itemnumber = ?");
2025        $sth_ano->execute($anonymouspatron, $borrowernumber, $itemnumber);
2026     }
2027     my $sth_del  = $dbh->prepare("DELETE FROM issues
2028                                   WHERE borrowernumber = ?
2029                                   AND itemnumber = ?");
2030     $sth_del->execute($borrowernumber, $itemnumber);
2031 }
2032
2033 =head2 _debar_user_on_return
2034
2035     _debar_user_on_return($borrower, $item, $datedue, today);
2036
2037 C<$borrower> borrower hashref
2038
2039 C<$item> item hashref
2040
2041 C<$datedue> date due DateTime object
2042
2043 C<$today> DateTime object representing the return time
2044
2045 Internal function, called only by AddReturn that calculates and updates
2046  the user fine days, and debars him if necessary.
2047
2048 Should only be called for overdue returns
2049
2050 =cut
2051
2052 sub _debar_user_on_return {
2053     my ( $borrower, $item, $dt_due, $dt_today ) = @_;
2054
2055     my $branchcode = _GetCircControlBranch( $item, $borrower );
2056     my $calendar = Koha::Calendar->new( branchcode => $branchcode );
2057
2058     # $deltadays is a DateTime::Duration object
2059     my $deltadays = $calendar->days_between( $dt_due, $dt_today );
2060
2061     my $circcontrol = C4::Context->preference('CircControl');
2062     my $issuingrule =
2063       GetIssuingRule( $borrower->{categorycode}, $item->{itype}, $branchcode );
2064     my $finedays = $issuingrule->{finedays};
2065     my $unit     = $issuingrule->{lengthunit};
2066
2067     if ($finedays) {
2068
2069         # finedays is in days, so hourly loans must multiply by 24
2070         # thus 1 hour late equals 1 day suspension * finedays rate
2071         $finedays = $finedays * 24 if ( $unit eq 'hours' );
2072
2073         # grace period is measured in the same units as the loan
2074         my $grace =
2075           DateTime::Duration->new( $unit => $issuingrule->{firstremind} );
2076         if ( $deltadays->subtract($grace)->is_positive() ) {
2077
2078             my $new_debar_dt =
2079               $dt_today->clone()->add_duration( $deltadays * $finedays );
2080
2081             Koha::Borrower::Debarments::AddUniqueDebarment({
2082                 borrowernumber => $borrower->{borrowernumber},
2083                 expiration     => $new_debar_dt->ymd(),
2084                 type           => 'SUSPENSION',
2085             });
2086
2087             return $new_debar_dt->ymd();
2088         }
2089     }
2090     return;
2091 }
2092
2093 =head2 _FixOverduesOnReturn
2094
2095    &_FixOverduesOnReturn($brn,$itm, $exemptfine, $dropboxmode);
2096
2097 C<$brn> borrowernumber
2098
2099 C<$itm> itemnumber
2100
2101 C<$exemptfine> BOOL -- remove overdue charge associated with this issue. 
2102 C<$dropboxmode> BOOL -- remove lastincrement on overdue charge associated with this issue.
2103
2104 Internal function, called only by AddReturn
2105
2106 =cut
2107
2108 sub _FixOverduesOnReturn {
2109     my ($borrowernumber, $item);
2110     unless ($borrowernumber = shift) {
2111         warn "_FixOverduesOnReturn() not supplied valid borrowernumber";
2112         return;
2113     }
2114     unless ($item = shift) {
2115         warn "_FixOverduesOnReturn() not supplied valid itemnumber";
2116         return;
2117     }
2118     my ($exemptfine, $dropbox) = @_;
2119     my $dbh = C4::Context->dbh;
2120
2121     # check for overdue fine
2122     my $sth = $dbh->prepare(
2123 "SELECT * FROM accountlines WHERE (borrowernumber = ?) AND (itemnumber = ?) AND (accounttype='FU' OR accounttype='O')"
2124     );
2125     $sth->execute( $borrowernumber, $item );
2126
2127     # alter fine to show that the book has been returned
2128     my $data = $sth->fetchrow_hashref;
2129     return 0 unless $data;    # no warning, there's just nothing to fix
2130
2131     my $uquery;
2132     my @bind = ($data->{'accountlines_id'});
2133     if ($exemptfine) {
2134         $uquery = "update accountlines set accounttype='FFOR', amountoutstanding=0";
2135         if (C4::Context->preference("FinesLog")) {
2136             &logaction("FINES", 'MODIFY',$borrowernumber,"Overdue forgiven: item $item");
2137         }
2138     } elsif ($dropbox && $data->{lastincrement}) {
2139         my $outstanding = $data->{amountoutstanding} - $data->{lastincrement} ;
2140         my $amt = $data->{amount} - $data->{lastincrement} ;
2141         if (C4::Context->preference("FinesLog")) {
2142             &logaction("FINES", 'MODIFY',$borrowernumber,"Dropbox adjustment $amt, item $item");
2143         }
2144          $uquery = "update accountlines set accounttype='F' ";
2145          if($outstanding  >= 0 && $amt >=0) {
2146             $uquery .= ", amount = ? , amountoutstanding=? ";
2147             unshift @bind, ($amt, $outstanding) ;
2148         }
2149     } else {
2150         $uquery = "update accountlines set accounttype='F' ";
2151     }
2152     $uquery .= " where (accountlines_id = ?)";
2153     my $usth = $dbh->prepare($uquery);
2154     return $usth->execute(@bind);
2155 }
2156
2157 =head2 _FixAccountForLostAndReturned
2158
2159   &_FixAccountForLostAndReturned($itemnumber, [$borrowernumber, $barcode]);
2160
2161 Calculates the charge for a book lost and returned.
2162
2163 Internal function, not exported, called only by AddReturn.
2164
2165 FIXME: This function reflects how inscrutable fines logic is.  Fix both.
2166 FIXME: Give a positive return value on success.  It might be the $borrowernumber who received credit, or the amount forgiven.
2167
2168 =cut
2169
2170 sub _FixAccountForLostAndReturned {
2171     my $itemnumber     = shift or return;
2172     my $borrowernumber = @_ ? shift : undef;
2173     my $item_id        = @_ ? shift : $itemnumber;  # Send the barcode if you want that logged in the description
2174     my $dbh = C4::Context->dbh;
2175     # check for charge made for lost book
2176     my $sth = $dbh->prepare("SELECT * FROM accountlines WHERE itemnumber = ? AND accounttype IN ('L', 'Rep', 'W') ORDER BY date DESC, accountno DESC");
2177     $sth->execute($itemnumber);
2178     my $data = $sth->fetchrow_hashref;
2179     $data or return;    # bail if there is nothing to do
2180     $data->{accounttype} eq 'W' and return;    # Written off
2181
2182     # writeoff this amount
2183     my $offset;
2184     my $amount = $data->{'amount'};
2185     my $acctno = $data->{'accountno'};
2186     my $amountleft;                                             # Starts off undef/zero.
2187     if ($data->{'amountoutstanding'} == $amount) {
2188         $offset     = $data->{'amount'};
2189         $amountleft = 0;                                        # Hey, it's zero here, too.
2190     } else {
2191         $offset     = $amount - $data->{'amountoutstanding'};   # Um, isn't this the same as ZERO?  We just tested those two things are ==
2192         $amountleft = $data->{'amountoutstanding'} - $amount;   # Um, isn't this the same as ZERO?  We just tested those two things are ==
2193     }
2194     my $usth = $dbh->prepare("UPDATE accountlines SET accounttype = 'LR',amountoutstanding='0'
2195         WHERE (accountlines_id = ?)");
2196     $usth->execute($data->{'accountlines_id'});      # We might be adjusting an account for some OTHER borrowernumber now.  Not the one we passed in.
2197     #check if any credit is left if so writeoff other accounts
2198     my $nextaccntno = getnextacctno($data->{'borrowernumber'});
2199     $amountleft *= -1 if ($amountleft < 0);
2200     if ($amountleft > 0) {
2201         my $msth = $dbh->prepare("SELECT * FROM accountlines WHERE (borrowernumber = ?)
2202                             AND (amountoutstanding >0) ORDER BY date");     # might want to order by amountoustanding ASC (pay smallest first)
2203         $msth->execute($data->{'borrowernumber'});
2204         # offset transactions
2205         my $newamtos;
2206         my $accdata;
2207         while (($accdata=$msth->fetchrow_hashref) and ($amountleft>0)){
2208             if ($accdata->{'amountoutstanding'} < $amountleft) {
2209                 $newamtos = 0;
2210                 $amountleft -= $accdata->{'amountoutstanding'};
2211             }  else {
2212                 $newamtos = $accdata->{'amountoutstanding'} - $amountleft;
2213                 $amountleft = 0;
2214             }
2215             my $thisacct = $accdata->{'accountlines_id'};
2216             # FIXME: move prepares outside while loop!
2217             my $usth = $dbh->prepare("UPDATE accountlines SET amountoutstanding= ?
2218                     WHERE (accountlines_id = ?)");
2219             $usth->execute($newamtos,$thisacct);
2220             $usth = $dbh->prepare("INSERT INTO accountoffsets
2221                 (borrowernumber, accountno, offsetaccount,  offsetamount)
2222                 VALUES
2223                 (?,?,?,?)");
2224             $usth->execute($data->{'borrowernumber'},$accdata->{'accountno'},$nextaccntno,$newamtos);
2225         }
2226     }
2227     $amountleft *= -1 if ($amountleft > 0);
2228     my $desc = "Item Returned " . $item_id;
2229     $usth = $dbh->prepare("INSERT INTO accountlines
2230         (borrowernumber,accountno,date,amount,description,accounttype,amountoutstanding)
2231         VALUES (?,?,now(),?,?,'CR',?)");
2232     $usth->execute($data->{'borrowernumber'},$nextaccntno,0-$amount,$desc,$amountleft);
2233     if ($borrowernumber) {
2234         # FIXME: same as query above.  use 1 sth for both
2235         $usth = $dbh->prepare("INSERT INTO accountoffsets
2236             (borrowernumber, accountno, offsetaccount,  offsetamount)
2237             VALUES (?,?,?,?)");
2238         $usth->execute($borrowernumber, $data->{'accountno'}, $nextaccntno, $offset);
2239     }
2240     ModItem({ paidfor => '' }, undef, $itemnumber);
2241     return;
2242 }
2243
2244 =head2 _GetCircControlBranch
2245
2246    my $circ_control_branch = _GetCircControlBranch($iteminfos, $borrower);
2247
2248 Internal function : 
2249
2250 Return the library code to be used to determine which circulation
2251 policy applies to a transaction.  Looks up the CircControl and
2252 HomeOrHoldingBranch system preferences.
2253
2254 C<$iteminfos> is a hashref to iteminfo. Only {homebranch or holdingbranch} is used.
2255
2256 C<$borrower> is a hashref to borrower. Only {branchcode} is used.
2257
2258 =cut
2259
2260 sub _GetCircControlBranch {
2261     my ($item, $borrower) = @_;
2262     my $circcontrol = C4::Context->preference('CircControl');
2263     my $branch;
2264
2265     if ($circcontrol eq 'PickupLibrary' and (C4::Context->userenv and C4::Context->userenv->{'branch'}) ) {
2266         $branch= C4::Context->userenv->{'branch'};
2267     } elsif ($circcontrol eq 'PatronLibrary') {
2268         $branch=$borrower->{branchcode};
2269     } else {
2270         my $branchfield = C4::Context->preference('HomeOrHoldingBranch') || 'homebranch';
2271         $branch = $item->{$branchfield};
2272         # default to item home branch if holdingbranch is used
2273         # and is not defined
2274         if (!defined($branch) && $branchfield eq 'holdingbranch') {
2275             $branch = $item->{homebranch};
2276         }
2277     }
2278     return $branch;
2279 }
2280
2281
2282
2283
2284
2285
2286 =head2 GetItemIssue
2287
2288   $issue = &GetItemIssue($itemnumber);
2289
2290 Returns patron currently having a book, or undef if not checked out.
2291
2292 C<$itemnumber> is the itemnumber.
2293
2294 C<$issue> is a hashref of the row from the issues table.
2295
2296 =cut
2297
2298 sub GetItemIssue {
2299     my ($itemnumber) = @_;
2300     return unless $itemnumber;
2301     my $sth = C4::Context->dbh->prepare(
2302         "SELECT items.*, issues.*
2303         FROM issues
2304         LEFT JOIN items ON issues.itemnumber=items.itemnumber
2305         WHERE issues.itemnumber=?");
2306     $sth->execute($itemnumber);
2307     my $data = $sth->fetchrow_hashref;
2308     return unless $data;
2309     $data->{issuedate} = dt_from_string($data->{issuedate}, 'sql');
2310     $data->{issuedate}->truncate(to => 'minute');
2311     $data->{date_due} = dt_from_string($data->{date_due}, 'sql');
2312     $data->{date_due}->truncate(to => 'minute');
2313     my $dt = DateTime->now( time_zone => C4::Context->tz)->truncate( to => 'minute');
2314     $data->{'overdue'} = DateTime->compare($data->{'date_due'}, $dt ) == -1 ? 1 : 0;
2315     return $data;
2316 }
2317
2318 =head2 GetOpenIssue
2319
2320   $issue = GetOpenIssue( $itemnumber );
2321
2322 Returns the row from the issues table if the item is currently issued, undef if the item is not currently issued
2323
2324 C<$itemnumber> is the item's itemnumber
2325
2326 Returns a hashref
2327
2328 =cut
2329
2330 sub GetOpenIssue {
2331   my ( $itemnumber ) = @_;
2332   return unless $itemnumber;
2333   my $dbh = C4::Context->dbh;  
2334   my $sth = $dbh->prepare( "SELECT * FROM issues WHERE itemnumber = ? AND returndate IS NULL" );
2335   $sth->execute( $itemnumber );
2336   return $sth->fetchrow_hashref();
2337
2338 }
2339
2340 =head2 GetIssues
2341
2342     $issues = GetIssues({});    # return all issues!
2343     $issues = GetIssues({ borrowernumber => $borrowernumber, biblionumber => $biblionumber });
2344
2345 Returns all pending issues that match given criteria.
2346 Returns a arrayref or undef if an error occurs.
2347
2348 Allowed criteria are:
2349
2350 =over 2
2351
2352 =item * borrowernumber
2353
2354 =item * biblionumber
2355
2356 =item * itemnumber
2357
2358 =back
2359
2360 =cut
2361
2362 sub GetIssues {
2363     my ($criteria) = @_;
2364
2365     # Build filters
2366     my @filters;
2367     my @allowed = qw(borrowernumber biblionumber itemnumber);
2368     foreach (@allowed) {
2369         if (defined $criteria->{$_}) {
2370             push @filters, {
2371                 field => $_,
2372                 value => $criteria->{$_},
2373             };
2374         }
2375     }
2376
2377     # Do we need to join other tables ?
2378     my %join;
2379     if (defined $criteria->{biblionumber}) {
2380         $join{items} = 1;
2381     }
2382
2383     # Build SQL query
2384     my $where = '';
2385     if (@filters) {
2386         $where = "WHERE " . join(' AND ', map { "$_->{field} = ?" } @filters);
2387     }
2388     my $query = q{
2389         SELECT issues.*
2390         FROM issues
2391     };
2392     if (defined $join{items}) {
2393         $query .= q{
2394             LEFT JOIN items ON (issues.itemnumber = items.itemnumber)
2395         };
2396     }
2397     $query .= $where;
2398
2399     # Execute SQL query
2400     my $dbh = C4::Context->dbh;
2401     my $sth = $dbh->prepare($query);
2402     my $rv = $sth->execute(map { $_->{value} } @filters);
2403
2404     return $rv ? $sth->fetchall_arrayref({}) : undef;
2405 }
2406
2407 =head2 GetItemIssues
2408
2409   $issues = &GetItemIssues($itemnumber, $history);
2410
2411 Returns patrons that have issued a book
2412
2413 C<$itemnumber> is the itemnumber
2414 C<$history> is false if you just want the current "issuer" (if any)
2415 and true if you want issues history from old_issues also.
2416
2417 Returns reference to an array of hashes
2418
2419 =cut
2420
2421 sub GetItemIssues {
2422     my ( $itemnumber, $history ) = @_;
2423     
2424     my $today = DateTime->now( time_zome => C4::Context->tz);  # get today date
2425     $today->truncate( to => 'minute' );
2426     my $sql = "SELECT * FROM issues
2427               JOIN borrowers USING (borrowernumber)
2428               JOIN items     USING (itemnumber)
2429               WHERE issues.itemnumber = ? ";
2430     if ($history) {
2431         $sql .= "UNION ALL
2432                  SELECT * FROM old_issues
2433                  LEFT JOIN borrowers USING (borrowernumber)
2434                  JOIN items USING (itemnumber)
2435                  WHERE old_issues.itemnumber = ? ";
2436     }
2437     $sql .= "ORDER BY date_due DESC";
2438     my $sth = C4::Context->dbh->prepare($sql);
2439     if ($history) {
2440         $sth->execute($itemnumber, $itemnumber);
2441     } else {
2442         $sth->execute($itemnumber);
2443     }
2444     my $results = $sth->fetchall_arrayref({});
2445     foreach (@$results) {
2446         my $date_due = dt_from_string($_->{date_due},'sql');
2447         $date_due->truncate( to => 'minute' );
2448
2449         $_->{overdue} = (DateTime->compare($date_due, $today) == -1) ? 1 : 0;
2450     }
2451     return $results;
2452 }
2453
2454 =head2 GetBiblioIssues
2455
2456   $issues = GetBiblioIssues($biblionumber);
2457
2458 this function get all issues from a biblionumber.
2459
2460 Return:
2461 C<$issues> is a reference to array which each value is ref-to-hash. This ref-to-hash containts all column from
2462 tables issues and the firstname,surname & cardnumber from borrowers.
2463
2464 =cut
2465
2466 sub GetBiblioIssues {
2467     my $biblionumber = shift;
2468     return unless $biblionumber;
2469     my $dbh   = C4::Context->dbh;
2470     my $query = "
2471         SELECT issues.*,items.barcode,biblio.biblionumber,biblio.title, biblio.author,borrowers.cardnumber,borrowers.surname,borrowers.firstname
2472         FROM issues
2473             LEFT JOIN borrowers ON borrowers.borrowernumber = issues.borrowernumber
2474             LEFT JOIN items ON issues.itemnumber = items.itemnumber
2475             LEFT JOIN biblioitems ON items.itemnumber = biblioitems.biblioitemnumber
2476             LEFT JOIN biblio ON biblio.biblionumber = items.biblionumber
2477         WHERE biblio.biblionumber = ?
2478         UNION ALL
2479         SELECT old_issues.*,items.barcode,biblio.biblionumber,biblio.title, biblio.author,borrowers.cardnumber,borrowers.surname,borrowers.firstname
2480         FROM old_issues
2481             LEFT JOIN borrowers ON borrowers.borrowernumber = old_issues.borrowernumber
2482             LEFT JOIN items ON old_issues.itemnumber = items.itemnumber
2483             LEFT JOIN biblioitems ON items.itemnumber = biblioitems.biblioitemnumber
2484             LEFT JOIN biblio ON biblio.biblionumber = items.biblionumber
2485         WHERE biblio.biblionumber = ?
2486         ORDER BY timestamp
2487     ";
2488     my $sth = $dbh->prepare($query);
2489     $sth->execute($biblionumber, $biblionumber);
2490
2491     my @issues;
2492     while ( my $data = $sth->fetchrow_hashref ) {
2493         push @issues, $data;
2494     }
2495     return \@issues;
2496 }
2497
2498 =head2 GetUpcomingDueIssues
2499
2500   my $upcoming_dues = GetUpcomingDueIssues( { days_in_advance => 4 } );
2501
2502 =cut
2503
2504 sub GetUpcomingDueIssues {
2505     my $params = shift;
2506
2507     $params->{'days_in_advance'} = 7 unless exists $params->{'days_in_advance'};
2508     my $dbh = C4::Context->dbh;
2509
2510     my $statement = <<END_SQL;
2511 SELECT issues.*, items.itype as itemtype, items.homebranch, TO_DAYS( date_due )-TO_DAYS( NOW() ) as days_until_due, branches.branchemail
2512 FROM issues 
2513 LEFT JOIN items USING (itemnumber)
2514 LEFT OUTER JOIN branches USING (branchcode)
2515 WHERE returndate is NULL
2516 HAVING days_until_due >= 0 AND days_until_due <= ?
2517 END_SQL
2518
2519     my @bind_parameters = ( $params->{'days_in_advance'} );
2520     
2521     my $sth = $dbh->prepare( $statement );
2522     $sth->execute( @bind_parameters );
2523     my $upcoming_dues = $sth->fetchall_arrayref({});
2524
2525     return $upcoming_dues;
2526 }
2527
2528 =head2 CanBookBeRenewed
2529
2530   ($ok,$error) = &CanBookBeRenewed($borrowernumber, $itemnumber[, $override_limit]);
2531
2532 Find out whether a borrowed item may be renewed.
2533
2534 C<$borrowernumber> is the borrower number of the patron who currently
2535 has the item on loan.
2536
2537 C<$itemnumber> is the number of the item to renew.
2538
2539 C<$override_limit>, if supplied with a true value, causes
2540 the limit on the number of times that the loan can be renewed
2541 (as controlled by the item type) to be ignored.
2542
2543 C<$CanBookBeRenewed> returns a true value if the item may be renewed. The
2544 item must currently be on loan to the specified borrower; renewals
2545 must be allowed for the item's type; and the borrower must not have
2546 already renewed the loan. $error will contain the reason the renewal can not proceed
2547
2548 =cut
2549
2550 sub CanBookBeRenewed {
2551     my ( $borrowernumber, $itemnumber, $override_limit ) = @_;
2552
2553     my $dbh       = C4::Context->dbh;
2554     my $renews    = 1;
2555     my $renewokay = 1;
2556     my $error;
2557
2558     my $item      = GetItem($itemnumber)      or return ( 0, 'no_item' );
2559     my $itemissue = GetItemIssue($itemnumber) or return ( 0, 'no_checkout' );
2560
2561     $borrowernumber ||= $itemissue->{borrowernumber};
2562     my $borrower = C4::Members::GetMember( borrowernumber => $borrowernumber )
2563       or return;
2564
2565     my $branchcode  = _GetCircControlBranch($item, $borrower);
2566
2567     my $issuingrule = GetIssuingRule($borrower->{categorycode}, $item->{itype}, $branchcode);
2568
2569     if ( $issuingrule->{norenewalbefore} ) {
2570
2571         # Get current time and add norenewalbefore. If this is smaller than date_due, it's too soon for renewal.
2572         if (
2573             DateTime->now( time_zone => C4::Context->tz() )->add(
2574                 $issuingrule->{lengthunit} => $issuingrule->{norenewalbefore}
2575             ) < $itemissue->{date_due}
2576         )
2577         {
2578             $renewokay = 0;
2579             $error     = "too_soon";
2580         }
2581     }
2582
2583     if ( $issuingrule->{renewalsallowed} <= $itemissue->{renewals} ) {
2584         $renewokay = 0;
2585         $error = "too_many";
2586     }
2587
2588     if ( $override_limit ) {
2589         $renewokay = 1;
2590         $error     = undef;
2591     }
2592
2593     my ( $resfound, $resrec, undef ) = C4::Reserves::CheckReserves( $itemnumber );
2594
2595     if ( $resfound ) { # '' when no hold was found
2596         $renewokay = 0;
2597         $error = "on_reserve";
2598     }
2599
2600     return ( $renewokay, $error );
2601 }
2602
2603 =head2 AddRenewal
2604
2605   &AddRenewal($borrowernumber, $itemnumber, $branch, [$datedue], [$lastreneweddate]);
2606
2607 Renews a loan.
2608
2609 C<$borrowernumber> is the borrower number of the patron who currently
2610 has the item.
2611
2612 C<$itemnumber> is the number of the item to renew.
2613
2614 C<$branch> is the library where the renewal took place (if any).
2615            The library that controls the circ policies for the renewal is retrieved from the issues record.
2616
2617 C<$datedue> can be a C4::Dates object used to set the due date.
2618
2619 C<$lastreneweddate> is an optional ISO-formatted date used to set issues.lastreneweddate.  If
2620 this parameter is not supplied, lastreneweddate is set to the current date.
2621
2622 If C<$datedue> is the empty string, C<&AddRenewal> will calculate the due date automatically
2623 from the book's item type.
2624
2625 =cut
2626
2627 sub AddRenewal {
2628     my $borrowernumber  = shift;
2629     my $itemnumber      = shift or return;
2630     my $branch          = shift;
2631     my $datedue         = shift;
2632     my $lastreneweddate = shift || DateTime->now(time_zone => C4::Context->tz)->ymd();
2633
2634     my $item   = GetItem($itemnumber) or return;
2635     my $biblio = GetBiblioFromItemNumber($itemnumber) or return;
2636
2637     my $dbh = C4::Context->dbh;
2638
2639     # Find the issues record for this book
2640     my $sth =
2641       $dbh->prepare("SELECT * FROM issues WHERE itemnumber = ?");
2642     $sth->execute( $itemnumber );
2643     my $issuedata = $sth->fetchrow_hashref;
2644
2645     return unless ( $issuedata );
2646
2647     $borrowernumber ||= $issuedata->{borrowernumber};
2648
2649     if ( defined $datedue && ref $datedue ne 'DateTime' ) {
2650         carp 'Invalid date passed to AddRenewal.';
2651         return;
2652     }
2653
2654     # If the due date wasn't specified, calculate it by adding the
2655     # book's loan length to today's date or the current due date
2656     # based on the value of the RenewalPeriodBase syspref.
2657     unless ($datedue) {
2658
2659         my $borrower = C4::Members::GetMember( borrowernumber => $borrowernumber ) or return;
2660         my $itemtype = (C4::Context->preference('item-level_itypes')) ? $biblio->{'itype'} : $biblio->{'itemtype'};
2661
2662         $datedue = (C4::Context->preference('RenewalPeriodBase') eq 'date_due') ?
2663                                         dt_from_string( $issuedata->{date_due} ) :
2664                                         DateTime->now( time_zone => C4::Context->tz());
2665         $datedue =  CalcDateDue($datedue, $itemtype, $issuedata->{'branchcode'}, $borrower, 'is a renewal');
2666     }
2667
2668     # Update the issues record to have the new due date, and a new count
2669     # of how many times it has been renewed.
2670     my $renews = $issuedata->{'renewals'} + 1;
2671     $sth = $dbh->prepare("UPDATE issues SET date_due = ?, renewals = ?, lastreneweddate = ?
2672                             WHERE borrowernumber=? 
2673                             AND itemnumber=?"
2674     );
2675
2676     $sth->execute( $datedue->strftime('%Y-%m-%d %H:%M'), $renews, $lastreneweddate, $borrowernumber, $itemnumber );
2677
2678     # Update the renewal count on the item, and tell zebra to reindex
2679     $renews = $biblio->{'renewals'} + 1;
2680     ModItem({ renewals => $renews, onloan => $datedue->strftime('%Y-%m-%d %H:%M')}, $biblio->{'biblionumber'}, $itemnumber);
2681
2682     # Charge a new rental fee, if applicable?
2683     my ( $charge, $type ) = GetIssuingCharges( $itemnumber, $borrowernumber );
2684     if ( $charge > 0 ) {
2685         my $accountno = getnextacctno( $borrowernumber );
2686         my $item = GetBiblioFromItemNumber($itemnumber);
2687         my $manager_id = 0;
2688         $manager_id = C4::Context->userenv->{'number'} if C4::Context->userenv; 
2689         $sth = $dbh->prepare(
2690                 "INSERT INTO accountlines
2691                     (date, borrowernumber, accountno, amount, manager_id,
2692                     description,accounttype, amountoutstanding, itemnumber)
2693                     VALUES (now(),?,?,?,?,?,?,?,?)"
2694         );
2695         $sth->execute( $borrowernumber, $accountno, $charge, $manager_id,
2696             "Renewal of Rental Item $item->{'title'} $item->{'barcode'}",
2697             'Rent', $charge, $itemnumber );
2698     }
2699
2700     # Send a renewal slip according to checkout alert preferencei
2701     if ( C4::Context->preference('RenewalSendNotice') eq '1') {
2702         my $borrower = C4::Members::GetMemberDetails( $borrowernumber, 0 );
2703         my $circulation_alert = 'C4::ItemCirculationAlertPreference';
2704         my %conditions = (
2705                 branchcode   => $branch,
2706                 categorycode => $borrower->{categorycode},
2707                 item_type    => $item->{itype},
2708                 notification => 'CHECKOUT',
2709         );
2710         if ($circulation_alert->is_enabled_for(\%conditions)) {
2711                 SendCirculationAlert({
2712                         type     => 'RENEWAL',
2713                         item     => $item,
2714                 borrower => $borrower,
2715                 branch   => $branch,
2716                 });
2717         }
2718     }
2719
2720     # Remove any OVERDUES related debarment if the borrower has no overdues
2721     my $borrower = C4::Members::GetMember( borrowernumber => $borrowernumber );
2722     if ( $borrowernumber
2723       && $borrower->{'debarred'}
2724       && !HasOverdues( $borrowernumber )
2725       && @{ GetDebarments({ borrowernumber => $borrowernumber, type => 'OVERDUES' }) }
2726     ) {
2727         DelUniqueDebarment({ borrowernumber => $borrowernumber, type => 'OVERDUES' });
2728     }
2729
2730     # Log the renewal
2731     UpdateStats( $branch, 'renew', $charge, '', $itemnumber, $item->{itype}, $borrowernumber, undef, $item->{'ccode'});
2732         return $datedue;
2733 }
2734
2735 sub GetRenewCount {
2736     # check renewal status
2737     my ( $bornum, $itemno ) = @_;
2738     my $dbh           = C4::Context->dbh;
2739     my $renewcount    = 0;
2740     my $renewsallowed = 0;
2741     my $renewsleft    = 0;
2742
2743     my $borrower = C4::Members::GetMember( borrowernumber => $bornum);
2744     my $item     = GetItem($itemno); 
2745
2746     # Look in the issues table for this item, lent to this borrower,
2747     # and not yet returned.
2748
2749     # FIXME - I think this function could be redone to use only one SQL call.
2750     my $sth = $dbh->prepare(
2751         "select * from issues
2752                                 where (borrowernumber = ?)
2753                                 and (itemnumber = ?)"
2754     );
2755     $sth->execute( $bornum, $itemno );
2756     my $data = $sth->fetchrow_hashref;
2757     $renewcount = $data->{'renewals'} if $data->{'renewals'};
2758     # $item and $borrower should be calculated
2759     my $branchcode = _GetCircControlBranch($item, $borrower);
2760     
2761     my $issuingrule = GetIssuingRule($borrower->{categorycode}, $item->{itype}, $branchcode);
2762     
2763     $renewsallowed = $issuingrule->{'renewalsallowed'};
2764     $renewsleft    = $renewsallowed - $renewcount;
2765     if($renewsleft < 0){ $renewsleft = 0; }
2766     return ( $renewcount, $renewsallowed, $renewsleft );
2767 }
2768
2769 =head2 GetSoonestRenewDate
2770
2771   $NoRenewalBeforeThisDate = &GetSoonestRenewDate($borrowernumber, $itemnumber);
2772
2773 Find out the soonest possible renew date of a borrowed item.
2774
2775 C<$borrowernumber> is the borrower number of the patron who currently
2776 has the item on loan.
2777
2778 C<$itemnumber> is the number of the item to renew.
2779
2780 C<$GetSoonestRenewDate> returns the DateTime of the soonest possible
2781 renew date, based on the value "No renewal before" of the applicable
2782 issuing rule. Returns the current date if the item can already be
2783 renewed, and returns undefined if the borrower, loan, or item
2784 cannot be found.
2785
2786 =cut
2787
2788 sub GetSoonestRenewDate {
2789     my ( $borrowernumber, $itemnumber ) = @_;
2790
2791     my $dbh = C4::Context->dbh;
2792
2793     my $item      = GetItem($itemnumber)      or return;
2794     my $itemissue = GetItemIssue($itemnumber) or return;
2795
2796     $borrowernumber ||= $itemissue->{borrowernumber};
2797     my $borrower = C4::Members::GetMemberDetails($borrowernumber)
2798       or return;
2799
2800     my $branchcode = _GetCircControlBranch( $item, $borrower );
2801     my $issuingrule =
2802       GetIssuingRule( $borrower->{categorycode}, $item->{itype}, $branchcode );
2803
2804     my $now = DateTime->now( time_zone => C4::Context->tz() );
2805
2806     if ( $issuingrule->{norenewalbefore} ) {
2807         my $soonestrenewal =
2808           $itemissue->{date_due}->subtract(
2809             $issuingrule->{lengthunit} => $issuingrule->{norenewalbefore} );
2810
2811         $soonestrenewal = $now > $soonestrenewal ? $now : $soonestrenewal;
2812         return $soonestrenewal;
2813     }
2814     return $now;
2815 }
2816
2817 =head2 GetIssuingCharges
2818
2819   ($charge, $item_type) = &GetIssuingCharges($itemnumber, $borrowernumber);
2820
2821 Calculate how much it would cost for a given patron to borrow a given
2822 item, including any applicable discounts.
2823
2824 C<$itemnumber> is the item number of item the patron wishes to borrow.
2825
2826 C<$borrowernumber> is the patron's borrower number.
2827
2828 C<&GetIssuingCharges> returns two values: C<$charge> is the rental charge,
2829 and C<$item_type> is the code for the item's item type (e.g., C<VID>
2830 if it's a video).
2831
2832 =cut
2833
2834 sub GetIssuingCharges {
2835
2836     # calculate charges due
2837     my ( $itemnumber, $borrowernumber ) = @_;
2838     my $charge = 0;
2839     my $dbh    = C4::Context->dbh;
2840     my $item_type;
2841
2842     # Get the book's item type and rental charge (via its biblioitem).
2843     my $charge_query = 'SELECT itemtypes.itemtype,rentalcharge FROM items
2844         LEFT JOIN biblioitems ON biblioitems.biblioitemnumber = items.biblioitemnumber';
2845     $charge_query .= (C4::Context->preference('item-level_itypes'))
2846         ? ' LEFT JOIN itemtypes ON items.itype = itemtypes.itemtype'
2847         : ' LEFT JOIN itemtypes ON biblioitems.itemtype = itemtypes.itemtype';
2848
2849     $charge_query .= ' WHERE items.itemnumber =?';
2850
2851     my $sth = $dbh->prepare($charge_query);
2852     $sth->execute($itemnumber);
2853     if ( my $item_data = $sth->fetchrow_hashref ) {
2854         $item_type = $item_data->{itemtype};
2855         $charge    = $item_data->{rentalcharge};
2856         my $branch = C4::Branch::mybranch();
2857         my $discount_query = q|SELECT rentaldiscount,
2858             issuingrules.itemtype, issuingrules.branchcode
2859             FROM borrowers
2860             LEFT JOIN issuingrules ON borrowers.categorycode = issuingrules.categorycode
2861             WHERE borrowers.borrowernumber = ?
2862             AND (issuingrules.itemtype = ? OR issuingrules.itemtype = '*')
2863             AND (issuingrules.branchcode = ? OR issuingrules.branchcode = '*')|;
2864         my $discount_sth = $dbh->prepare($discount_query);
2865         $discount_sth->execute( $borrowernumber, $item_type, $branch );
2866         my $discount_rules = $discount_sth->fetchall_arrayref({});
2867         if (@{$discount_rules}) {
2868             # We may have multiple rules so get the most specific
2869             my $discount = _get_discount_from_rule($discount_rules, $branch, $item_type);
2870             $charge = ( $charge * ( 100 - $discount ) ) / 100;
2871         }
2872     }
2873
2874     return ( $charge, $item_type );
2875 }
2876
2877 # Select most appropriate discount rule from those returned
2878 sub _get_discount_from_rule {
2879     my ($rules_ref, $branch, $itemtype) = @_;
2880     my $discount;
2881
2882     if (@{$rules_ref} == 1) { # only 1 applicable rule use it
2883         $discount = $rules_ref->[0]->{rentaldiscount};
2884         return (defined $discount) ? $discount : 0;
2885     }
2886     # could have up to 4 does one match $branch and $itemtype
2887     my @d = grep { $_->{branchcode} eq $branch && $_->{itemtype} eq $itemtype } @{$rules_ref};
2888     if (@d) {
2889         $discount = $d[0]->{rentaldiscount};
2890         return (defined $discount) ? $discount : 0;
2891     }
2892     # do we have item type + all branches
2893     @d = grep { $_->{branchcode} eq q{*} && $_->{itemtype} eq $itemtype } @{$rules_ref};
2894     if (@d) {
2895         $discount = $d[0]->{rentaldiscount};
2896         return (defined $discount) ? $discount : 0;
2897     }
2898     # do we all item types + this branch
2899     @d = grep { $_->{branchcode} eq $branch && $_->{itemtype} eq q{*} } @{$rules_ref};
2900     if (@d) {
2901         $discount = $d[0]->{rentaldiscount};
2902         return (defined $discount) ? $discount : 0;
2903     }
2904     # so all and all (surely we wont get here)
2905     @d = grep { $_->{branchcode} eq q{*} && $_->{itemtype} eq q{*} } @{$rules_ref};
2906     if (@d) {
2907         $discount = $d[0]->{rentaldiscount};
2908         return (defined $discount) ? $discount : 0;
2909     }
2910     # none of the above
2911     return 0;
2912 }
2913
2914 =head2 AddIssuingCharge
2915
2916   &AddIssuingCharge( $itemno, $borrowernumber, $charge )
2917
2918 =cut
2919
2920 sub AddIssuingCharge {
2921     my ( $itemnumber, $borrowernumber, $charge ) = @_;
2922     my $dbh = C4::Context->dbh;
2923     my $nextaccntno = getnextacctno( $borrowernumber );
2924     my $manager_id = 0;
2925     $manager_id = C4::Context->userenv->{'number'} if C4::Context->userenv;
2926     my $query ="
2927         INSERT INTO accountlines
2928             (borrowernumber, itemnumber, accountno,
2929             date, amount, description, accounttype,
2930             amountoutstanding, manager_id)
2931         VALUES (?, ?, ?,now(), ?, 'Rental', 'Rent',?,?)
2932     ";
2933     my $sth = $dbh->prepare($query);
2934     $sth->execute( $borrowernumber, $itemnumber, $nextaccntno, $charge, $charge, $manager_id );
2935 }
2936
2937 =head2 GetTransfers
2938
2939   GetTransfers($itemnumber);
2940
2941 =cut
2942
2943 sub GetTransfers {
2944     my ($itemnumber) = @_;
2945
2946     my $dbh = C4::Context->dbh;
2947
2948     my $query = '
2949         SELECT datesent,
2950                frombranch,
2951                tobranch
2952         FROM branchtransfers
2953         WHERE itemnumber = ?
2954           AND datearrived IS NULL
2955         ';
2956     my $sth = $dbh->prepare($query);
2957     $sth->execute($itemnumber);
2958     my @row = $sth->fetchrow_array();
2959     return @row;
2960 }
2961
2962 =head2 GetTransfersFromTo
2963
2964   @results = GetTransfersFromTo($frombranch,$tobranch);
2965
2966 Returns the list of pending transfers between $from and $to branch
2967
2968 =cut
2969
2970 sub GetTransfersFromTo {
2971     my ( $frombranch, $tobranch ) = @_;
2972     return unless ( $frombranch && $tobranch );
2973     my $dbh   = C4::Context->dbh;
2974     my $query = "
2975         SELECT itemnumber,datesent,frombranch
2976         FROM   branchtransfers
2977         WHERE  frombranch=?
2978           AND  tobranch=?
2979           AND datearrived IS NULL
2980     ";
2981     my $sth = $dbh->prepare($query);
2982     $sth->execute( $frombranch, $tobranch );
2983     my @gettransfers;
2984
2985     while ( my $data = $sth->fetchrow_hashref ) {
2986         push @gettransfers, $data;
2987     }
2988     return (@gettransfers);
2989 }
2990
2991 =head2 DeleteTransfer
2992
2993   &DeleteTransfer($itemnumber);
2994
2995 =cut
2996
2997 sub DeleteTransfer {
2998     my ($itemnumber) = @_;
2999     return unless $itemnumber;
3000     my $dbh          = C4::Context->dbh;
3001     my $sth          = $dbh->prepare(
3002         "DELETE FROM branchtransfers
3003          WHERE itemnumber=?
3004          AND datearrived IS NULL "
3005     );
3006     return $sth->execute($itemnumber);
3007 }
3008
3009 =head2 AnonymiseIssueHistory
3010
3011   ($rows,$err_history_not_deleted) = AnonymiseIssueHistory($date,$borrowernumber)
3012
3013 This function write NULL instead of C<$borrowernumber> given on input arg into the table issues.
3014 if C<$borrowernumber> is not set, it will delete the issue history for all borrower older than C<$date>.
3015
3016 If c<$borrowernumber> is set, it will delete issue history for only that borrower, regardless of their opac privacy
3017 setting (force delete).
3018
3019 return the number of affected rows and a value that evaluates to true if an error occurred deleting the history.
3020
3021 =cut
3022
3023 sub AnonymiseIssueHistory {
3024     my $date           = shift;
3025     my $borrowernumber = shift;
3026     my $dbh            = C4::Context->dbh;
3027     my $query          = "
3028         UPDATE old_issues
3029         SET    borrowernumber = ?
3030         WHERE  returndate < ?
3031           AND borrowernumber IS NOT NULL
3032     ";
3033
3034     # The default of 0 does not work due to foreign key constraints
3035     # The anonymisation will fail quietly if AnonymousPatron is not a valid entry
3036     my $anonymouspatron = (C4::Context->preference('AnonymousPatron')) ? C4::Context->preference('AnonymousPatron') : 0;
3037     my @bind_params = ($anonymouspatron, $date);
3038     if (defined $borrowernumber) {
3039        $query .= " AND borrowernumber = ?";
3040        push @bind_params, $borrowernumber;
3041     } else {
3042        $query .= " AND (SELECT privacy FROM borrowers WHERE borrowers.borrowernumber=old_issues.borrowernumber) <> 0";
3043     }
3044     my $sth = $dbh->prepare($query);
3045     $sth->execute(@bind_params);
3046     my $anonymisation_err = $dbh->err;
3047     my $rows_affected = $sth->rows;  ### doublecheck row count return function
3048     return ($rows_affected, $anonymisation_err);
3049 }
3050
3051 =head2 SendCirculationAlert
3052
3053 Send out a C<check-in> or C<checkout> alert using the messaging system.
3054
3055 B<Parameters>:
3056
3057 =over 4
3058
3059 =item type
3060
3061 Valid values for this parameter are: C<CHECKIN> and C<CHECKOUT>.
3062
3063 =item item
3064
3065 Hashref of information about the item being checked in or out.
3066
3067 =item borrower
3068
3069 Hashref of information about the borrower of the item.
3070
3071 =item branch
3072
3073 The branchcode from where the checkout or check-in took place.
3074
3075 =back
3076
3077 B<Example>:
3078
3079     SendCirculationAlert({
3080         type     => 'CHECKOUT',
3081         item     => $item,
3082         borrower => $borrower,
3083         branch   => $branch,
3084     });
3085
3086 =cut
3087
3088 sub SendCirculationAlert {
3089     my ($opts) = @_;
3090     my ($type, $item, $borrower, $branch) =
3091         ($opts->{type}, $opts->{item}, $opts->{borrower}, $opts->{branch});
3092     my %message_name = (
3093         CHECKIN  => 'Item_Check_in',
3094         CHECKOUT => 'Item_Checkout',
3095         RENEWAL  => 'Item_Checkout',
3096     );
3097     my $borrower_preferences = C4::Members::Messaging::GetMessagingPreferences({
3098         borrowernumber => $borrower->{borrowernumber},
3099         message_name   => $message_name{$type},
3100     });
3101     my $issues_table = ( $type eq 'CHECKOUT' || $type eq 'RENEWAL' ) ? 'issues' : 'old_issues';
3102     my $letter =  C4::Letters::GetPreparedLetter (
3103         module => 'circulation',
3104         letter_code => $type,
3105         branchcode => $branch,
3106         tables => {
3107             $issues_table => $item->{itemnumber},
3108             'items'       => $item->{itemnumber},
3109             'biblio'      => $item->{biblionumber},
3110             'biblioitems' => $item->{biblionumber},
3111             'borrowers'   => $borrower,
3112             'branches'    => $branch,
3113         }
3114     ) or return;
3115
3116     my @transports = keys %{ $borrower_preferences->{transports} };
3117     # warn "no transports" unless @transports;
3118     for (@transports) {
3119         # warn "transport: $_";
3120         my $message = C4::Message->find_last_message($borrower, $type, $_);
3121         if (!$message) {
3122             #warn "create new message";
3123             C4::Message->enqueue($letter, $borrower, $_);
3124         } else {
3125             #warn "append to old message";
3126             $message->append($letter);
3127             $message->update;
3128         }
3129     }
3130
3131     return $letter;
3132 }
3133
3134 =head2 updateWrongTransfer
3135
3136   $items = updateWrongTransfer($itemNumber,$borrowernumber,$waitingAtLibrary,$FromLibrary);
3137
3138 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 
3139
3140 =cut
3141
3142 sub updateWrongTransfer {
3143         my ( $itemNumber,$waitingAtLibrary,$FromLibrary ) = @_;
3144         my $dbh = C4::Context->dbh;     
3145 # first step validate the actual line of transfert .
3146         my $sth =
3147                 $dbh->prepare(
3148                         "update branchtransfers set datearrived = now(),tobranch=?,comments='wrongtransfer' where itemnumber= ? AND datearrived IS NULL"
3149                 );
3150                 $sth->execute($FromLibrary,$itemNumber);
3151
3152 # second step create a new line of branchtransfer to the right location .
3153         ModItemTransfer($itemNumber, $FromLibrary, $waitingAtLibrary);
3154
3155 #third step changing holdingbranch of item
3156         UpdateHoldingbranch($FromLibrary,$itemNumber);
3157 }
3158
3159 =head2 UpdateHoldingbranch
3160
3161   $items = UpdateHoldingbranch($branch,$itmenumber);
3162
3163 Simple methode for updating hodlingbranch in items BDD line
3164
3165 =cut
3166
3167 sub UpdateHoldingbranch {
3168         my ( $branch,$itemnumber ) = @_;
3169     ModItem({ holdingbranch => $branch }, undef, $itemnumber);
3170 }
3171
3172 =head2 CalcDateDue
3173
3174 $newdatedue = CalcDateDue($startdate,$itemtype,$branchcode,$borrower);
3175
3176 this function calculates the due date given the start date and configured circulation rules,
3177 checking against the holidays calendar as per the 'useDaysMode' syspref.
3178 C<$startdate>   = C4::Dates object representing start date of loan period (assumed to be today)
3179 C<$itemtype>  = itemtype code of item in question
3180 C<$branch>  = location whose calendar to use
3181 C<$borrower> = Borrower object
3182 C<$isrenewal> = Boolean: is true if we want to calculate the date due for a renewal. Else is false.
3183
3184 =cut
3185
3186 sub CalcDateDue {
3187     my ( $startdate, $itemtype, $branch, $borrower, $isrenewal ) = @_;
3188
3189     $isrenewal ||= 0;
3190
3191     # loanlength now a href
3192     my $loanlength =
3193             GetLoanLength( $borrower->{'categorycode'}, $itemtype, $branch );
3194
3195     my $length_key = ( $isrenewal and defined $loanlength->{renewalperiod} )
3196             ? qq{renewalperiod}
3197             : qq{issuelength};
3198
3199     my $datedue;
3200     if ( $startdate ) {
3201         if (ref $startdate ne 'DateTime' ) {
3202             $datedue = dt_from_string($datedue);
3203         } else {
3204             $datedue = $startdate->clone;
3205         }
3206     } else {
3207         $datedue =
3208           DateTime->now( time_zone => C4::Context->tz() )
3209           ->truncate( to => 'minute' );
3210     }
3211
3212
3213     # calculate the datedue as normal
3214     if ( C4::Context->preference('useDaysMode') eq 'Days' )
3215     {    # ignoring calendar
3216         if ( $loanlength->{lengthunit} eq 'hours' ) {
3217             $datedue->add( hours => $loanlength->{$length_key} );
3218         } else {    # days
3219             $datedue->add( days => $loanlength->{$length_key} );
3220             $datedue->set_hour(23);
3221             $datedue->set_minute(59);
3222         }
3223     } else {
3224         my $dur;
3225         if ($loanlength->{lengthunit} eq 'hours') {
3226             $dur = DateTime::Duration->new( hours => $loanlength->{$length_key});
3227         }
3228         else { # days
3229             $dur = DateTime::Duration->new( days => $loanlength->{$length_key});
3230         }
3231         my $calendar = Koha::Calendar->new( branchcode => $branch );
3232         $datedue = $calendar->addDate( $datedue, $dur, $loanlength->{lengthunit} );
3233         if ($loanlength->{lengthunit} eq 'days') {
3234             $datedue->set_hour(23);
3235             $datedue->set_minute(59);
3236         }
3237     }
3238
3239     # if Hard Due Dates are used, retreive them and apply as necessary
3240     my ( $hardduedate, $hardduedatecompare ) =
3241       GetHardDueDate( $borrower->{'categorycode'}, $itemtype, $branch );
3242     if ($hardduedate) {    # hardduedates are currently dates
3243         $hardduedate->truncate( to => 'minute' );
3244         $hardduedate->set_hour(23);
3245         $hardduedate->set_minute(59);
3246         my $cmp = DateTime->compare( $hardduedate, $datedue );
3247
3248 # if the calculated due date is after the 'before' Hard Due Date (ceiling), override
3249 # if the calculated date is before the 'after' Hard Due Date (floor), override
3250 # if the hard due date is set to 'exactly', overrride
3251         if ( $hardduedatecompare == 0 || $hardduedatecompare == $cmp ) {
3252             $datedue = $hardduedate->clone;
3253         }
3254
3255         # in all other cases, keep the date due as it is
3256
3257     }
3258
3259     # if ReturnBeforeExpiry ON the datedue can't be after borrower expirydate
3260     if ( C4::Context->preference('ReturnBeforeExpiry') ) {
3261         my $expiry_dt = dt_from_string( $borrower->{dateexpiry}, 'iso' );
3262         $expiry_dt->set( hour => 23, minute => 59);
3263         if ( DateTime->compare( $datedue, $expiry_dt ) == 1 ) {
3264             $datedue = $expiry_dt->clone;
3265         }
3266     }
3267
3268     return $datedue;
3269 }
3270
3271
3272 =head2 CheckRepeatableHolidays
3273
3274   $countrepeatable = CheckRepeatableHoliday($itemnumber,$week_day,$branchcode);
3275
3276 This function checks if the date due is a repeatable holiday
3277
3278 C<$date_due>   = returndate calculate with no day check
3279 C<$itemnumber>  = itemnumber
3280 C<$branchcode>  = localisation of issue 
3281
3282 =cut
3283
3284 sub CheckRepeatableHolidays{
3285 my($itemnumber,$week_day,$branchcode)=@_;
3286 my $dbh = C4::Context->dbh;
3287 my $query = qq|SELECT count(*)  
3288         FROM repeatable_holidays 
3289         WHERE branchcode=?
3290         AND weekday=?|;
3291 my $sth = $dbh->prepare($query);
3292 $sth->execute($branchcode,$week_day);
3293 my $result=$sth->fetchrow;
3294 return $result;
3295 }
3296
3297
3298 =head2 CheckSpecialHolidays
3299
3300   $countspecial = CheckSpecialHolidays($years,$month,$day,$itemnumber,$branchcode);
3301
3302 This function check if the date is a special holiday
3303
3304 C<$years>   = the years of datedue
3305 C<$month>   = the month of datedue
3306 C<$day>     = the day of datedue
3307 C<$itemnumber>  = itemnumber
3308 C<$branchcode>  = localisation of issue 
3309
3310 =cut
3311
3312 sub CheckSpecialHolidays{
3313 my ($years,$month,$day,$itemnumber,$branchcode) = @_;
3314 my $dbh = C4::Context->dbh;
3315 my $query=qq|SELECT count(*) 
3316              FROM `special_holidays`
3317              WHERE year=?
3318              AND month=?
3319              AND day=?
3320              AND branchcode=?
3321             |;
3322 my $sth = $dbh->prepare($query);
3323 $sth->execute($years,$month,$day,$branchcode);
3324 my $countspecial=$sth->fetchrow ;
3325 return $countspecial;
3326 }
3327
3328 =head2 CheckRepeatableSpecialHolidays
3329
3330   $countspecial = CheckRepeatableSpecialHolidays($month,$day,$itemnumber,$branchcode);
3331
3332 This function check if the date is a repeatble special holidays
3333
3334 C<$month>   = the month of datedue
3335 C<$day>     = the day of datedue
3336 C<$itemnumber>  = itemnumber
3337 C<$branchcode>  = localisation of issue 
3338
3339 =cut
3340
3341 sub CheckRepeatableSpecialHolidays{
3342 my ($month,$day,$itemnumber,$branchcode) = @_;
3343 my $dbh = C4::Context->dbh;
3344 my $query=qq|SELECT count(*) 
3345              FROM `repeatable_holidays`
3346              WHERE month=?
3347              AND day=?
3348              AND branchcode=?
3349             |;
3350 my $sth = $dbh->prepare($query);
3351 $sth->execute($month,$day,$branchcode);
3352 my $countspecial=$sth->fetchrow ;
3353 return $countspecial;
3354 }
3355
3356
3357
3358 sub CheckValidBarcode{
3359 my ($barcode) = @_;
3360 my $dbh = C4::Context->dbh;
3361 my $query=qq|SELECT count(*) 
3362              FROM items 
3363              WHERE barcode=?
3364             |;
3365 my $sth = $dbh->prepare($query);
3366 $sth->execute($barcode);
3367 my $exist=$sth->fetchrow ;
3368 return $exist;
3369 }
3370
3371 =head2 IsBranchTransferAllowed
3372
3373   $allowed = IsBranchTransferAllowed( $toBranch, $fromBranch, $code );
3374
3375 Code is either an itemtype or collection doe depending on the pref BranchTransferLimitsType
3376
3377 =cut
3378
3379 sub IsBranchTransferAllowed {
3380         my ( $toBranch, $fromBranch, $code ) = @_;
3381
3382         if ( $toBranch eq $fromBranch ) { return 1; } ## Short circuit for speed.
3383         
3384         my $limitType = C4::Context->preference("BranchTransferLimitsType");   
3385         my $dbh = C4::Context->dbh;
3386             
3387         my $sth = $dbh->prepare("SELECT * FROM branch_transfer_limits WHERE toBranch = ? AND fromBranch = ? AND $limitType = ?");
3388         $sth->execute( $toBranch, $fromBranch, $code );
3389         my $limit = $sth->fetchrow_hashref();
3390                         
3391         ## If a row is found, then that combination is not allowed, if no matching row is found, then the combination *is allowed*
3392         if ( $limit->{'limitId'} ) {
3393                 return 0;
3394         } else {
3395                 return 1;
3396         }
3397 }                                                        
3398
3399 =head2 CreateBranchTransferLimit
3400
3401   CreateBranchTransferLimit( $toBranch, $fromBranch, $code );
3402
3403 $code is either itemtype or collection code depending on what the pref BranchTransferLimitsType is set to.
3404
3405 =cut
3406
3407 sub CreateBranchTransferLimit {
3408    my ( $toBranch, $fromBranch, $code ) = @_;
3409    return unless defined($toBranch) && defined($fromBranch);
3410    my $limitType = C4::Context->preference("BranchTransferLimitsType");
3411    
3412    my $dbh = C4::Context->dbh;
3413    
3414    my $sth = $dbh->prepare("INSERT INTO branch_transfer_limits ( $limitType, toBranch, fromBranch ) VALUES ( ?, ?, ? )");
3415    return $sth->execute( $code, $toBranch, $fromBranch );
3416 }
3417
3418 =head2 DeleteBranchTransferLimits
3419
3420     my $result = DeleteBranchTransferLimits($frombranch);
3421
3422 Deletes all the library transfer limits for one library.  Returns the
3423 number of limits deleted, 0e0 if no limits were deleted, or undef if
3424 no arguments are supplied.
3425
3426 =cut
3427
3428 sub DeleteBranchTransferLimits {
3429     my $branch = shift;
3430     return unless defined $branch;
3431     my $dbh    = C4::Context->dbh;
3432     my $sth    = $dbh->prepare("DELETE FROM branch_transfer_limits WHERE fromBranch = ?");
3433     return $sth->execute($branch);
3434 }
3435
3436 sub ReturnLostItem{
3437     my ( $borrowernumber, $itemnum ) = @_;
3438
3439     MarkIssueReturned( $borrowernumber, $itemnum );
3440     my $borrower = C4::Members::GetMember( 'borrowernumber'=>$borrowernumber );
3441     my $item = C4::Items::GetItem( $itemnum );
3442     my $old_note = ($item->{'paidfor'} && ($item->{'paidfor'} ne q{})) ? $item->{'paidfor'}.' / ' : q{};
3443     my @datearr = localtime(time);
3444     my $date = ( 1900 + $datearr[5] ) . "-" . ( $datearr[4] + 1 ) . "-" . $datearr[3];
3445     my $bor = "$borrower->{'firstname'} $borrower->{'surname'} $borrower->{'cardnumber'}";
3446     ModItem({ paidfor =>  $old_note."Paid for by $bor $date" }, undef, $itemnum);
3447 }
3448
3449
3450 sub LostItem{
3451     my ($itemnumber, $mark_returned) = @_;
3452
3453     my $dbh = C4::Context->dbh();
3454     my $sth=$dbh->prepare("SELECT issues.*,items.*,biblio.title 
3455                            FROM issues 
3456                            JOIN items USING (itemnumber) 
3457                            JOIN biblio USING (biblionumber)
3458                            WHERE issues.itemnumber=?");
3459     $sth->execute($itemnumber);
3460     my $issues=$sth->fetchrow_hashref();
3461
3462     # If a borrower lost the item, add a replacement cost to the their record
3463     if ( my $borrowernumber = $issues->{borrowernumber} ){
3464         my $borrower = C4::Members::GetMemberDetails( $borrowernumber );
3465
3466         if (C4::Context->preference('WhenLostForgiveFine')){
3467             my $fix = _FixOverduesOnReturn($borrowernumber, $itemnumber, 1, 0); # 1, 0 = exemptfine, no-dropbox
3468             defined($fix) or warn "_FixOverduesOnReturn($borrowernumber, $itemnumber...) failed!";  # zero is OK, check defined
3469         }
3470         if (C4::Context->preference('WhenLostChargeReplacementFee')){
3471             C4::Accounts::chargelostitem($borrowernumber, $itemnumber, $issues->{'replacementprice'}, "Lost Item $issues->{'title'} $issues->{'barcode'}");
3472             #FIXME : Should probably have a way to distinguish this from an item that really was returned.
3473             #warn " $issues->{'borrowernumber'}  /  $itemnumber ";
3474         }
3475
3476         MarkIssueReturned($borrowernumber,$itemnumber,undef,undef,$borrower->{'privacy'}) if $mark_returned;
3477     }
3478 }
3479
3480 sub GetOfflineOperations {
3481     my $dbh = C4::Context->dbh;
3482     my $sth = $dbh->prepare("SELECT * FROM pending_offline_operations WHERE branchcode=? ORDER BY timestamp");
3483     $sth->execute(C4::Context->userenv->{'branch'});
3484     my $results = $sth->fetchall_arrayref({});
3485     return $results;
3486 }
3487
3488 sub GetOfflineOperation {
3489     my $operationid = shift;
3490     return unless $operationid;
3491     my $dbh = C4::Context->dbh;
3492     my $sth = $dbh->prepare("SELECT * FROM pending_offline_operations WHERE operationid=?");
3493     $sth->execute( $operationid );
3494     return $sth->fetchrow_hashref;
3495 }
3496
3497 sub AddOfflineOperation {
3498     my ( $userid, $branchcode, $timestamp, $action, $barcode, $cardnumber, $amount ) = @_;
3499     my $dbh = C4::Context->dbh;
3500     my $sth = $dbh->prepare("INSERT INTO pending_offline_operations (userid, branchcode, timestamp, action, barcode, cardnumber, amount) VALUES(?,?,?,?,?,?,?)");
3501     $sth->execute( $userid, $branchcode, $timestamp, $action, $barcode, $cardnumber, $amount );
3502     return "Added.";
3503 }
3504
3505 sub DeleteOfflineOperation {
3506     my $dbh = C4::Context->dbh;
3507     my $sth = $dbh->prepare("DELETE FROM pending_offline_operations WHERE operationid=?");
3508     $sth->execute( shift );
3509     return "Deleted.";
3510 }
3511
3512 sub ProcessOfflineOperation {
3513     my $operation = shift;
3514
3515     my $report;
3516     if ( $operation->{action} eq 'return' ) {
3517         $report = ProcessOfflineReturn( $operation );
3518     } elsif ( $operation->{action} eq 'issue' ) {
3519         $report = ProcessOfflineIssue( $operation );
3520     } elsif ( $operation->{action} eq 'payment' ) {
3521         $report = ProcessOfflinePayment( $operation );
3522     }
3523
3524     DeleteOfflineOperation( $operation->{operationid} ) if $operation->{operationid};
3525
3526     return $report;
3527 }
3528
3529 sub ProcessOfflineReturn {
3530     my $operation = shift;
3531
3532     my $itemnumber = C4::Items::GetItemnumberFromBarcode( $operation->{barcode} );
3533
3534     if ( $itemnumber ) {
3535         my $issue = GetOpenIssue( $itemnumber );
3536         if ( $issue ) {
3537             MarkIssueReturned(
3538                 $issue->{borrowernumber},
3539                 $itemnumber,
3540                 undef,
3541                 $operation->{timestamp},
3542             );
3543             ModItem(
3544                 { renewals => 0, onloan => undef },
3545                 $issue->{'biblionumber'},
3546                 $itemnumber
3547             );
3548             return "Success.";
3549         } else {
3550             return "Item not issued.";
3551         }
3552     } else {
3553         return "Item not found.";
3554     }
3555 }
3556
3557 sub ProcessOfflineIssue {
3558     my $operation = shift;
3559
3560     my $borrower = C4::Members::GetMemberDetails( undef, $operation->{cardnumber} ); # Get borrower from operation cardnumber
3561
3562     if ( $borrower->{borrowernumber} ) {
3563         my $itemnumber = C4::Items::GetItemnumberFromBarcode( $operation->{barcode} );
3564         unless ($itemnumber) {
3565             return "Barcode not found.";
3566         }
3567         my $issue = GetOpenIssue( $itemnumber );
3568
3569         if ( $issue and ( $issue->{borrowernumber} ne $borrower->{borrowernumber} ) ) { # Item already issued to another borrower, mark it returned
3570             MarkIssueReturned(
3571                 $issue->{borrowernumber},
3572                 $itemnumber,
3573                 undef,
3574                 $operation->{timestamp},
3575             );
3576         }
3577         AddIssue(
3578             $borrower,
3579             $operation->{'barcode'},
3580             undef,
3581             1,
3582             $operation->{timestamp},
3583             undef,
3584         );
3585         return "Success.";
3586     } else {
3587         return "Borrower not found.";
3588     }
3589 }
3590
3591 sub ProcessOfflinePayment {
3592     my $operation = shift;
3593
3594     my $borrower = C4::Members::GetMemberDetails( undef, $operation->{cardnumber} ); # Get borrower from operation cardnumber
3595     my $amount = $operation->{amount};
3596
3597     recordpayment( $borrower->{borrowernumber}, $amount );
3598
3599     return "Success."
3600 }
3601
3602
3603 =head2 TransferSlip
3604
3605   TransferSlip($user_branch, $itemnumber, $to_branch)
3606
3607   Returns letter hash ( see C4::Letters::GetPreparedLetter ) or undef
3608
3609 =cut
3610
3611 sub TransferSlip {
3612     my ($branch, $itemnumber, $to_branch) = @_;
3613
3614     my $item =  GetItem( $itemnumber )
3615       or return;
3616
3617     my $pulldate = C4::Dates->new();
3618
3619     return C4::Letters::GetPreparedLetter (
3620         module => 'circulation',
3621         letter_code =>