C4/Overdues.pm

   1 package C4::Overdues;
   2
   3
   4 # Copyright 2000-2002 Katipo Communications
   5 # copyright 2010 BibLibre
   6 #
   7 # This file is part of Koha.
   8 #
   9 # Koha is free software; you can redistribute it and/or modify it
  10 # under the terms of the GNU General Public License as published by
  11 # the Free Software Foundation; either version 3 of the License, or
  12 # (at your option) any later version.
  13 #
  14 # Koha is distributed in the hope that it will be useful, but
  15 # WITHOUT ANY WARRANTY; without even the implied warranty of
  16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17 # GNU General Public License for more details.
  18 #
  19 # You should have received a copy of the GNU General Public License
  20 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  21
  22 use strict;
  23 #use warnings; FIXME - Bug 2505
  24 use Date::Calc qw/Today Date_to_Days/;
  25 use Date::Manip qw/UnixDate/;
  26 use List::MoreUtils qw( uniq );
  27 use POSIX qw( floor ceil );
  28 use Locale::Currency::Format 1.28;
  29 use Carp;
  30
  31 use C4::Circulation;
  32 use C4::Context;
  33 use C4::Accounts;
  34 use C4::Log; # logaction
  35 use C4::Debug;
  36 use Koha::DateUtils;
  37 use Koha::Account::Lines;
  38 use Koha::Account::Offsets;
  39 use Koha::IssuingRules;
  40 use Koha::Libraries;
  41
  42 use vars qw(@ISA @EXPORT);
  43
  44 BEGIN {
  45     require Exporter;
  46     @ISA = qw(Exporter);
  47
  48     # subs to rename (and maybe merge some...)
  49     push @EXPORT, qw(
  50       &CalcFine
  51       &Getoverdues
  52       &checkoverdues
  53       &UpdateFine
  54       &GetFine
  55       &get_chargeable_units
  56       &GetOverduesForBranch
  57       &GetOverdueMessageTransportTypes
  58       &parse_overdues_letter
  59     );
  60
  61     # subs to remove
  62     push @EXPORT, qw(
  63       &BorType
  64     );
  65
  66     # check that an equivalent don't exist already before moving
  67
  68     # subs to move to Circulation.pm
  69     push @EXPORT, qw(
  70       &GetIssuesIteminfo
  71     );
  72 }
  73
  74 =head1 NAME
  75
  76 C4::Circulation::Fines - Koha module dealing with fines
  77
  78 =head1 SYNOPSIS
  79
  80   use C4::Overdues;
  81
  82 =head1 DESCRIPTION
  83
  84 This module contains several functions for dealing with fines for
  85 overdue items. It is primarily used by the 'misc/fines2.pl' script.
  86
  87 =head1 FUNCTIONS
  88
  89 =head2 Getoverdues
  90
  91   $overdues = Getoverdues( { minimumdays => 1, maximumdays => 30 } );
  92
  93 Returns the list of all overdue books, with their itemtype.
  94
  95 C<$overdues> is a reference-to-array. Each element is a
  96 reference-to-hash whose keys are the fields of the issues table in the
  97 Koha database.
  98
  99 =cut
 100
 101 #'
 102 sub Getoverdues {
 103     my $params = shift;
 104     my $dbh = C4::Context->dbh;
 105     my $statement;
 106     if ( C4::Context->preference('item-level_itypes') ) {
 107         $statement = "
 108    SELECT issues.*, items.itype as itemtype, items.homebranch, items.barcode, items.itemlost, items.replacementprice
 109      FROM issues
 110 LEFT JOIN items       USING (itemnumber)
 111     WHERE date_due < NOW()
 112 ";
 113     } else {
 114         $statement = "
 115    SELECT issues.*, biblioitems.itemtype, items.itype, items.homebranch, items.barcode, items.itemlost, replacementprice
 116      FROM issues
 117 LEFT JOIN items       USING (itemnumber)
 118 LEFT JOIN biblioitems USING (biblioitemnumber)
 119     WHERE date_due < NOW()
 120 ";
 121     }
 122
 123     my @bind_parameters;
 124     if ( exists $params->{'minimumdays'} and exists $params->{'maximumdays'} ) {
 125         $statement .= ' AND TO_DAYS( NOW() )-TO_DAYS( date_due ) BETWEEN ? and ? ';
 126         push @bind_parameters, $params->{'minimumdays'}, $params->{'maximumdays'};
 127     } elsif ( exists $params->{'minimumdays'} ) {
 128         $statement .= ' AND ( TO_DAYS( NOW() )-TO_DAYS( date_due ) ) > ? ';
 129         push @bind_parameters, $params->{'minimumdays'};
 130     } elsif ( exists $params->{'maximumdays'} ) {
 131         $statement .= ' AND ( TO_DAYS( NOW() )-TO_DAYS( date_due ) ) < ? ';
 132         push @bind_parameters, $params->{'maximumdays'};
 133     }
 134     $statement .= 'ORDER BY borrowernumber';
 135     my $sth = $dbh->prepare( $statement );
 136     $sth->execute( @bind_parameters );
 137     return $sth->fetchall_arrayref({});
 138 }
 139
 140
 141 =head2 checkoverdues
 142
 143     ($count, $overdueitems) = checkoverdues($borrowernumber);
 144
 145 Returns a count and a list of overdueitems for a given borrowernumber
 146
 147 =cut
 148
 149 sub checkoverdues {
 150     my $borrowernumber = shift or return;
 151     my $sth = C4::Context->dbh->prepare(
 152         "SELECT biblio.*, items.*, issues.*,
 153                 biblioitems.volume,
 154                 biblioitems.number,
 155                 biblioitems.itemtype,
 156                 biblioitems.isbn,
 157                 biblioitems.issn,
 158                 biblioitems.publicationyear,
 159                 biblioitems.publishercode,
 160                 biblioitems.volumedate,
 161                 biblioitems.volumedesc,
 162                 biblioitems.collectiontitle,
 163                 biblioitems.collectionissn,
 164                 biblioitems.collectionvolume,
 165                 biblioitems.editionstatement,
 166                 biblioitems.editionresponsibility,
 167                 biblioitems.illus,
 168                 biblioitems.pages,
 169                 biblioitems.notes,
 170                 biblioitems.size,
 171                 biblioitems.place,
 172                 biblioitems.lccn,
 173                 biblioitems.url,
 174                 biblioitems.cn_source,
 175                 biblioitems.cn_class,
 176                 biblioitems.cn_item,
 177                 biblioitems.cn_suffix,
 178                 biblioitems.cn_sort,
 179                 biblioitems.totalissues
 180          FROM issues
 181          LEFT JOIN items       ON issues.itemnumber      = items.itemnumber
 182          LEFT JOIN biblio      ON items.biblionumber     = biblio.biblionumber
 183          LEFT JOIN biblioitems ON items.biblioitemnumber = biblioitems.biblioitemnumber
 184             WHERE issues.borrowernumber  = ?
 185             AND   issues.date_due < NOW()"
 186     );
 187     $sth->execute($borrowernumber);
 188     my $results = $sth->fetchall_arrayref({});
 189     return ( scalar(@$results), $results);  # returning the count and the results is silly
 190 }
 191
 192 =head2 CalcFine
 193
 194     ($amount, $units_minus_grace, $chargeable_units) = &CalcFine($item,
 195                                   $categorycode, $branch,
 196                                   $start_dt, $end_dt );
 197
 198 Calculates the fine for a book.
 199
 200 The issuingrules table in the Koha database is a fine matrix, listing
 201 the penalties for each type of patron for each type of item and each branch (e.g., the
 202 standard fine for books might be $0.50, but $1.50 for DVDs, or staff
 203 members might get a longer grace period between the first and second
 204 reminders that a book is overdue).
 205
 206
 207 C<$item> is an item object (hashref).
 208
 209 C<$categorycode> is the category code (string) of the patron who currently has
 210 the book.
 211
 212 C<$branchcode> is the library (string) whose issuingrules govern this transaction.
 213
 214 C<$start_date> & C<$end_date> are DateTime objects
 215 defining the date range over which to determine the fine.
 216
 217 Fines scripts should just supply the date range over which to calculate the fine.
 218
 219 C<&CalcFine> returns three values:
 220
 221 C<$amount> is the fine owed by the patron (see above).
 222
 223 C<$units_minus_grace> is the number of chargeable units minus the grace period
 224
 225 C<$chargeable_units> is the number of chargeable units (days between start and end dates, Calendar adjusted where needed,
 226 minus any applicable grace period, or hours)
 227
 228 FIXME: previously attempted to return C<$message> as a text message, either "First Notice", "Second Notice",
 229 or "Final Notice".  But CalcFine never defined any value.
 230
 231 =cut
 232
 233 sub CalcFine {
 234     my ( $item, $bortype, $branchcode, $due_dt, $end_date  ) = @_;
 235
 236     # Skip calculations if item is not overdue
 237     return ( 0, 0, 0 ) unless (DateTime->compare( $due_dt, $end_date ) == -1);
 238
 239     my $start_date = $due_dt->clone();
 240     # get issuingrules (fines part will be used)
 241     my $itemtype = $item->{itemtype} || $item->{itype};
 242     my $issuing_rule = Koha::IssuingRules->get_effective_issuing_rule({ categorycode => $bortype, itemtype => $itemtype, branchcode => $branchcode });
 243
 244     $itemtype = Koha::ItemTypes->find($itemtype);
 245
 246     return unless $issuing_rule; # If not rule exist, there is no fine
 247
 248     my $fine_unit = $issuing_rule->lengthunit || 'days';
 249
 250     my $chargeable_units = get_chargeable_units($fine_unit, $start_date, $end_date, $branchcode);
 251     my $units_minus_grace = $chargeable_units - $issuing_rule->firstremind;
 252     my $amount = 0;
 253     if ( $issuing_rule->chargeperiod && ( $units_minus_grace > 0 ) ) {
 254         my $units = C4::Context->preference('FinesIncludeGracePeriod') ? $chargeable_units : $units_minus_grace;
 255         my $charge_periods = $units / $issuing_rule->chargeperiod;
 256         # If chargeperiod_charge_at = 1, we charge a fine at the start of each charge period
 257         # if chargeperiod_charge_at = 0, we charge at the end of each charge period
 258         $charge_periods = $issuing_rule->chargeperiod_charge_at == 1 ? ceil($charge_periods) : floor($charge_periods);
 259         $amount = $charge_periods * $issuing_rule->fine;
 260     } # else { # a zero (or null) chargeperiod or negative units_minus_grace value means no charge. }
 261
 262     $amount = $issuing_rule->overduefinescap if $issuing_rule->overduefinescap && $amount > $issuing_rule->overduefinescap;
 263
 264     # This must be moved to Koha::Item (see also similar code in C4::Accounts::chargelostitem
 265     $item->{replacementprice} ||= $itemtype->defaultreplacecost
 266       if $itemtype
 267       && $item->{replacementprice} == 0
 268       && C4::Context->preference("useDefaultReplacementCost");
 269
 270     $amount = $item->{replacementprice} if ( $issuing_rule->cap_fine_to_replacement_price && $item->{replacementprice} && $amount > $item->{replacementprice} );
 271
 272     $debug and warn sprintf("CalcFine returning (%s, %s, %s)", $amount, $units_minus_grace, $chargeable_units);
 273     return ($amount, $units_minus_grace, $chargeable_units);
 274 }
 275
 276
 277 =head2 get_chargeable_units
 278
 279     get_chargeable_units($unit, $start_date_ $end_date, $branchcode);
 280
 281 return integer value of units between C<$start_date> and C<$end_date>, factoring in holidays for C<$branchcode>.
 282
 283 C<$unit> is 'days' or 'hours' (default is 'days').
 284
 285 C<$start_date> and C<$end_date> are the two DateTimes to get the number of units between.
 286
 287 C<$branchcode> is the branch whose calendar to use for finding holidays.
 288
 289 =cut
 290
 291 sub get_chargeable_units {
 292     my ($unit, $date_due, $date_returned, $branchcode) = @_;
 293
 294     # If the due date is later than the return date
 295     return 0 unless ( $date_returned > $date_due );
 296
 297     my $charge_units = 0;
 298     my $charge_duration;
 299     if ($unit eq 'hours') {
 300         if(C4::Context->preference('finesCalendar') eq 'noFinesWhenClosed') {
 301             my $calendar = Koha::Calendar->new( branchcode => $branchcode );
 302             $charge_duration = $calendar->hours_between( $date_due, $date_returned );
 303         } else {
 304             $charge_duration = $date_returned->delta_ms( $date_due );
 305         }
 306         if($charge_duration->in_units('hours') == 0 && $charge_duration->in_units('seconds') > 0){
 307             return 1;
 308         }
 309         return $charge_duration->in_units('hours');
 310     }
 311     else { # days
 312         if(C4::Context->preference('finesCalendar') eq 'noFinesWhenClosed') {
 313             my $calendar = Koha::Calendar->new( branchcode => $branchcode );
 314             $charge_duration = $calendar->days_between( $date_due, $date_returned );
 315         } else {
 316             $charge_duration = $date_returned->delta_days( $date_due );
 317         }
 318         return $charge_duration->in_units('days');
 319     }
 320 }
 321
 322
 323 =head2 GetSpecialHolidays
 324
 325     &GetSpecialHolidays($date_dues,$itemnumber);
 326
 327 return number of special days  between date of the day and date due
 328
 329 C<$date_dues> is the envisaged date of book return.
 330
 331 C<$itemnumber> is the book's item number.
 332
 333 =cut
 334
 335 sub GetSpecialHolidays {
 336     my ( $date_dues, $itemnumber ) = @_;
 337
 338     # calcul the today date
 339     my $today = join "-", &Today();
 340
 341     # return the holdingbranch
 342     my $iteminfo = GetIssuesIteminfo($itemnumber);
 343
 344     # use sql request to find all date between date_due and today
 345     my $dbh = C4::Context->dbh;
 346     my $query =
 347       qq|SELECT DATE_FORMAT(concat(year,'-',month,'-',day),'%Y-%m-%d') as date
 348 FROM `special_holidays`
 349 WHERE DATE_FORMAT(concat(year,'-',month,'-',day),'%Y-%m-%d') >= ?
 350 AND   DATE_FORMAT(concat(year,'-',month,'-',day),'%Y-%m-%d') <= ?
 351 AND branchcode=?
 352 |;
 353     my @result = GetWdayFromItemnumber($itemnumber);
 354     my @result_date;
 355     my $wday;
 356     my $dateinsec;
 357     my $sth = $dbh->prepare($query);
 358     $sth->execute( $date_dues, $today, $iteminfo->{'branchcode'} )
 359       ;    # FIXME: just use NOW() in SQL instead of passing in $today
 360
 361     while ( my $special_date = $sth->fetchrow_hashref ) {
 362         push( @result_date, $special_date );
 363     }
 364
 365     my $specialdaycount = scalar(@result_date);
 366
 367     for ( my $i = 0 ; $i < scalar(@result_date) ; $i++ ) {
 368         $dateinsec = UnixDate( $result_date[$i]->{'date'}, "%o" );
 369         ( undef, undef, undef, undef, undef, undef, $wday, undef, undef ) =
 370           localtime($dateinsec);
 371         for ( my $j = 0 ; $j < scalar(@result) ; $j++ ) {
 372             if ( $wday == ( $result[$j]->{'weekday'} ) ) {
 373                 $specialdaycount--;
 374             }
 375         }
 376     }
 377
 378     return $specialdaycount;
 379 }
 380
 381 =head2 GetRepeatableHolidays
 382
 383     &GetRepeatableHolidays($date_dues, $itemnumber, $difference,);
 384
 385 return number of day closed between date of the day and date due
 386
 387 C<$date_dues> is the envisaged date of book return.
 388
 389 C<$itemnumber> is item number.
 390
 391 C<$difference> numbers of between day date of the day and date due
 392
 393 =cut
 394
 395 sub GetRepeatableHolidays {
 396     my ( $date_dues, $itemnumber, $difference ) = @_;
 397     my $dateinsec = UnixDate( $date_dues, "%o" );
 398     my ( $sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst ) =
 399       localtime($dateinsec);
 400     my @result = GetWdayFromItemnumber($itemnumber);
 401     my @dayclosedcount;
 402     my $j;
 403
 404     for ( my $i = 0 ; $i < scalar(@result) ; $i++ ) {
 405         my $k = $wday;
 406
 407         for ( $j = 0 ; $j < $difference ; $j++ ) {
 408             if ( $result[$i]->{'weekday'} == $k ) {
 409                 push( @dayclosedcount, $k );
 410             }
 411             $k++;
 412             ( $k = 0 ) if ( $k eq 7 );
 413         }
 414     }
 415     return scalar(@dayclosedcount);
 416 }
 417
 418
 419 =head2 GetWayFromItemnumber
 420
 421     &Getwdayfromitemnumber($itemnumber);
 422
 423 return the different week day from repeatable_holidays table
 424
 425 C<$itemnumber> is  item number.
 426
 427 =cut
 428
 429 sub GetWdayFromItemnumber {
 430     my ($itemnumber) = @_;
 431     my $iteminfo = GetIssuesIteminfo($itemnumber);
 432     my @result;
 433     my $query = qq|SELECT weekday
 434     FROM repeatable_holidays
 435     WHERE branchcode=?
 436 |;
 437     my $sth = C4::Context->dbh->prepare($query);
 438
 439     $sth->execute( $iteminfo->{'branchcode'} );
 440     while ( my $weekday = $sth->fetchrow_hashref ) {
 441         push( @result, $weekday );
 442     }
 443     return @result;
 444 }
 445
 446
 447 =head2 GetIssuesIteminfo
 448
 449     &GetIssuesIteminfo($itemnumber);
 450
 451 return all data from issues about item
 452
 453 C<$itemnumber> is  item number.
 454
 455 =cut
 456
 457 sub GetIssuesIteminfo {
 458     my ($itemnumber) = @_;
 459     my $dbh          = C4::Context->dbh;
 460     my $query        = qq|SELECT *
 461     FROM issues
 462     WHERE itemnumber=?
 463     |;
 464     my $sth = $dbh->prepare($query);
 465     $sth->execute($itemnumber);
 466     my ($issuesinfo) = $sth->fetchrow_hashref;
 467     return $issuesinfo;
 468 }
 469
 470
 471 =head2 UpdateFine
 472
 473     &UpdateFine(
 474         {
 475             issue_id       => $issue_id,
 476             itemnumber     => $itemnumber,
 477             borrowernumber => $borrowernumber,
 478             amount         => $amount,
 479             due            => $date_due
 480         }
 481     );
 482
 483 (Note: the following is mostly conjecture and guesswork.)
 484
 485 Updates the fine owed on an overdue book.
 486
 487 C<$itemnumber> is the book's item number.
 488
 489 C<$borrowernumber> is the borrower number of the patron who currently
 490 has the book on loan.
 491
 492 C<$amount> is the current amount owed by the patron.
 493
 494 C<$due> is the due date formatted to the currently specified date format
 495
 496 C<&UpdateFine> looks up the amount currently owed on the given item
 497 and sets it to C<$amount>, creating, if necessary, a new entry in the
 498 accountlines table of the Koha database.
 499
 500 =cut
 501
 502 #
 503 # Question: Why should the caller have to
 504 # specify both the item number and the borrower number? A book can't
 505 # be on loan to two different people, so the item number should be
 506 # sufficient.
 507 #
 508 # Possible Answer: You might update a fine for a damaged item, *after* it is returned.
 509 #
 510 sub UpdateFine {
 511     my ($params) = @_;
 512
 513     my $issue_id       = $params->{issue_id};
 514     my $itemnum        = $params->{itemnumber};
 515     my $borrowernumber = $params->{borrowernumber};
 516     my $amount         = $params->{amount};
 517     my $due            = $params->{due};
 518
 519     $debug and warn "UpdateFine({ itemnumber => $itemnum, borrowernumber => $borrowernumber, due => $due, issue_id => $issue_id})";
 520
 521     unless ( $issue_id ) {
 522         carp("No issue_id passed in!");
 523         return;
 524     }
 525
 526     my $dbh = C4::Context->dbh;
 527     my $overdues = Koha::Account::Lines->search(
 528         {
 529             borrowernumber    => $borrowernumber,
 530             debit_type_code   => 'OVERDUE',
 531             amountoutstanding => { '<>' => 0 }
 532         }
 533     );
 534
 535     my $accountline;
 536     my $total_amount_other = 0.00;
 537     my $due_qr = qr/$due/;
 538     # Cycle through the fines and
 539     # - find line that relates to the requested $itemnum
 540     # - accumulate fines for other items
 541     # so we can update $itemnum fine taking in account fine caps
 542     while (my $overdue = $overdues->next) {
 543         if ( $overdue->issue_id == $issue_id && $overdue->status eq 'UNRETURNED' ) {
 544             if ($accountline) {
 545                 $debug and warn "Not a unique accountlines record for issue_id $issue_id";
 546                 #FIXME Should we still count this one in total_amount ??
 547             }
 548             else {
 549                 $accountline = $overdue;
 550                 next;
 551             }
 552         }
 553         $total_amount_other += $overdue->amountoutstanding;
 554     }
 555
 556     if (my $maxfine = C4::Context->preference('MaxFine')) {
 557         if ($total_amount_other + $amount > $maxfine) {
 558             my $new_amount = $maxfine - $total_amount_other;
 559             return if $new_amount <= 0.00;
 560             $debug and warn "Reducing fine for item $itemnum borrower $borrowernumber from $amount to $new_amount - MaxFine reached";
 561             $amount = $new_amount;
 562         }
 563     }
 564
 565
 566     if ( $accountline ) {
 567         if ( $accountline->amount != $amount ) {
 568             $accountline->adjust(
 569                 {
 570                     amount    => $amount,
 571                     type      => 'overdue_update',
 572                     interface => C4::Context->interface
 573                 }
 574             );
 575         }
 576     } else {
 577         if ( $amount ) { # Don't add new fines with an amount of 0
 578             my $sth4 = $dbh->prepare(
 579                 "SELECT title FROM biblio LEFT JOIN items ON biblio.biblionumber=items.biblionumber WHERE items.itemnumber=?"
 580             );
 581             $sth4->execute($itemnum);
 582             my $title = $sth4->fetchrow;
 583             my $desc = "$title $due";
 584
 585             my $account = Koha::Account->new({ patron_id => $borrowernumber });
 586             $accountline = $account->add_debit(
 587                 {
 588                     amount      => $amount,
 589                     description => $desc,
 590                     note        => undef,
 591                     user_id     => undef,
 592                     interface   => C4::Context->interface,
 593                     library_id  => undef, #FIXME: Should we grab the checkout or circ-control branch here perhaps?
 594                     type        => 'OVERDUE',
 595                     item_id     => $itemnum,
 596                     issue_id    => $issue_id,
 597                 }
 598             );
 599         }
 600     }
 601 }
 602
 603 =head2 BorType
 604
 605     $borrower = &BorType($borrowernumber);
 606
 607 Looks up a patron by borrower number.
 608
 609 C<$borrower> is a reference-to-hash whose keys are all of the fields
 610 from the borrowers and categories tables of the Koha database. Thus,
 611 C<$borrower> contains all information about both the borrower and
 612 category they belong to.
 613
 614 =cut
 615
 616 sub BorType {
 617     my ($borrowernumber) = @_;
 618     my $dbh              = C4::Context->dbh;
 619     my $sth              = $dbh->prepare(
 620         "SELECT * from borrowers
 621       LEFT JOIN categories ON borrowers.categorycode=categories.categorycode
 622       WHERE borrowernumber=?"
 623     );
 624     $sth->execute($borrowernumber);
 625     return $sth->fetchrow_hashref;
 626 }
 627
 628 =head2 GetFine
 629
 630     $data->{'sum(amountoutstanding)'} = &GetFine($itemnum,$borrowernumber);
 631
 632 return the total of fine
 633
 634 C<$itemnum> is item number
 635
 636 C<$borrowernumber> is the borrowernumber
 637
 638 =cut
 639
 640 sub GetFine {
 641     my ( $itemnum, $borrowernumber ) = @_;
 642     my $dbh   = C4::Context->dbh();
 643     my $query = q|SELECT sum(amountoutstanding) as fineamount FROM accountlines
 644     WHERE debit_type_code = 'OVERDUE'
 645   AND amountoutstanding > 0 AND borrowernumber=?|;
 646     my @query_param;
 647     push @query_param, $borrowernumber;
 648     if (defined $itemnum )
 649     {
 650         $query .= " AND itemnumber=?";
 651         push @query_param, $itemnum;
 652     }
 653     my $sth = $dbh->prepare($query);
 654     $sth->execute( @query_param );
 655     my $fine = $sth->fetchrow_hashref();
 656     if ($fine->{fineamount}) {
 657         return $fine->{fineamount};
 658     }
 659     return 0;
 660 }
 661
 662 =head2 GetBranchcodesWithOverdueRules
 663
 664     my @branchcodes = C4::Overdues::GetBranchcodesWithOverdueRules()
 665
 666 returns a list of branch codes for branches with overdue rules defined.
 667
 668 =cut
 669
 670 sub GetBranchcodesWithOverdueRules {
 671     my $dbh               = C4::Context->dbh;
 672     my $branchcodes = $dbh->selectcol_arrayref(q|
 673         SELECT DISTINCT(branchcode)
 674         FROM overduerules
 675         WHERE delay1 IS NOT NULL
 676         ORDER BY branchcode
 677     |);
 678     if ( $branchcodes->[0] eq '' ) {
 679         # If a default rule exists, all branches should be returned
 680         return map { $_->branchcode } Koha::Libraries->search({}, { order_by => 'branchname' });
 681     }
 682     return @$branchcodes;
 683 }
 684
 685 =head2 GetOverduesForBranch
 686
 687 Sql request for display all information for branchoverdues.pl
 688 2 possibilities : with or without location .
 689 display is filtered by branch
 690
 691 FIXME: This function should be renamed.
 692
 693 =cut
 694
 695 sub GetOverduesForBranch {
 696     my ( $branch, $location) = @_;
 697         my $itype_link =  (C4::Context->preference('item-level_itypes')) ?  " items.itype " :  " biblioitems.itemtype ";
 698     my $dbh = C4::Context->dbh;
 699     my $select = "
 700     SELECT
 701             borrowers.cardnumber,
 702             borrowers.borrowernumber,
 703             borrowers.surname,
 704             borrowers.firstname,
 705             borrowers.phone,
 706             borrowers.email,
 707                biblio.title,
 708                biblio.subtitle,
 709                biblio.medium,
 710                biblio.part_number,
 711                biblio.part_name,
 712                biblio.author,
 713                biblio.biblionumber,
 714                issues.date_due,
 715                issues.returndate,
 716                issues.branchcode,
 717              branches.branchname,
 718                 items.barcode,
 719                 items.homebranch,
 720                 items.itemcallnumber,
 721                 items.location,
 722                 items.itemnumber,
 723             itemtypes.description,
 724          accountlines.amountoutstanding
 725     FROM  accountlines
 726     LEFT JOIN issues      ON    issues.itemnumber     = accountlines.itemnumber
 727                           AND   issues.borrowernumber = accountlines.borrowernumber
 728     LEFT JOIN borrowers   ON borrowers.borrowernumber = accountlines.borrowernumber
 729     LEFT JOIN items       ON     items.itemnumber     = issues.itemnumber
 730     LEFT JOIN biblio      ON      biblio.biblionumber =  items.biblionumber
 731     LEFT JOIN biblioitems ON biblioitems.biblioitemnumber = items.biblioitemnumber
 732     LEFT JOIN itemtypes   ON itemtypes.itemtype       = $itype_link
 733     LEFT JOIN branches    ON  branches.branchcode     = issues.branchcode
 734     WHERE (accountlines.amountoutstanding  != '0.000000')
 735       AND (accountlines.debit_type_code     = 'OVERDUE' )
 736       AND (accountlines.status              = 'UNRETURNED' )
 737       AND (issues.branchcode =  ?   )
 738       AND (issues.date_due  < NOW())
 739     ";
 740     if ($location) {
 741         my $q = "$select AND items.location = ? ORDER BY borrowers.surname, borrowers.firstname";
 742         return @{ $dbh->selectall_arrayref($q, { Slice => {} }, $branch, $location ) };
 743     } else {
 744         my $q = "$select ORDER BY borrowers.surname, borrowers.firstname";
 745         return @{ $dbh->selectall_arrayref($q, { Slice => {} }, $branch ) };
 746     }
 747 }
 748
 749 =head2 GetOverdueMessageTransportTypes
 750
 751     my $message_transport_types = GetOverdueMessageTransportTypes( $branchcode, $categorycode, $letternumber);
 752
 753     return a arrayref with all message_transport_type for given branchcode, categorycode and letternumber(1,2 or 3)
 754
 755 =cut
 756
 757 sub GetOverdueMessageTransportTypes {
 758     my ( $branchcode, $categorycode, $letternumber ) = @_;
 759     return unless $categorycode and $letternumber;
 760     my $dbh = C4::Context->dbh;
 761     my $sth = $dbh->prepare("
 762         SELECT message_transport_type
 763         FROM overduerules odr LEFT JOIN overduerules_transport_types ott USING (overduerules_id)
 764         WHERE branchcode = ?
 765           AND categorycode = ?
 766           AND letternumber = ?
 767     ");
 768     $sth->execute( $branchcode, $categorycode, $letternumber );
 769     my @mtts;
 770     while ( my $mtt = $sth->fetchrow ) {
 771         push @mtts, $mtt;
 772     }
 773
 774     # Put 'print' in first if exists
 775     # It avoid to sent a print notice with an email or sms template is no email or sms is defined
 776     @mtts = uniq( 'print', @mtts )
 777         if grep {/^print$/} @mtts;
 778
 779     return \@mtts;
 780 }
 781
 782 =head2 parse_overdues_letter
 783
 784 parses the letter template, replacing the placeholders with data
 785 specific to this patron, biblio, or item for overdues
 786
 787 named parameters:
 788   letter - required hashref
 789   borrowernumber - required integer
 790   substitute - optional hashref of other key/value pairs that should
 791     be substituted in the letter content
 792
 793 returns the C<letter> hashref, with the content updated to reflect the
 794 substituted keys and values.
 795
 796 =cut
 797
 798 sub parse_overdues_letter {
 799     my $params = shift;
 800     foreach my $required (qw( letter_code borrowernumber )) {
 801         return unless ( exists $params->{$required} && $params->{$required} );
 802     }
 803
 804     my $patron = Koha::Patrons->find( $params->{borrowernumber} );
 805
 806     my $substitute = $params->{'substitute'} || {};
 807
 808     my %tables = ( 'borrowers' => $params->{'borrowernumber'} );
 809     if ( my $p = $params->{'branchcode'} ) {
 810         $tables{'branches'} = $p;
 811     }
 812
 813     my $active_currency = Koha::Acquisition::Currencies->get_active;
 814
 815     my $currency_format;
 816     $currency_format = $active_currency->currency if defined($active_currency);
 817
 818     my @item_tables;
 819     if ( my $i = $params->{'items'} ) {
 820         foreach my $item (@$i) {
 821             my $fine = GetFine($item->{'itemnumber'}, $params->{'borrowernumber'});
 822             $item->{'fine'} = currency_format($currency_format, "$fine", FMT_SYMBOL);
 823             # if active currency isn't correct ISO code fallback to sprintf
 824             $item->{'fine'} = sprintf('%.2f', $fine) unless $item->{'fine'};
 825
 826             push @item_tables, {
 827                 'biblio' => $item->{'biblionumber'},
 828                 'biblioitems' => $item->{'biblionumber'},
 829                 'items' => $item,
 830                 'issues' => $item->{'itemnumber'},
 831             };
 832         }
 833     }
 834
 835     return C4::Letters::GetPreparedLetter (
 836         module => 'circulation',
 837         letter_code => $params->{'letter_code'},
 838         branchcode => $params->{'branchcode'},
 839         lang => $patron->lang,
 840         tables => \%tables,
 841         loops => {
 842             overdues => [ map { $_->{items}->{itemnumber} } @item_tables ],
 843         },
 844         substitute => $substitute,
 845         repeat => { item => \@item_tables },
 846         message_transport_type => $params->{message_transport_type},
 847     );
 848 }
 849
 850 1;
 851 __END__
 852
 853 =head1 AUTHOR
 854
 855 Koha Development Team <http://koha-community.org/>
 856
 857 =cut