Koha/Account.pm

   1 package Koha::Account;
   2
   3 # Copyright 2016 ByWater Solutions
   4 #
   5 # This file is part of Koha.
   6 #
   7 # Koha is free software; you can redistribute it and/or modify it
   8 # under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # Koha is distributed in the hope that it will be useful, but
  13 # WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  19
  20 use Modern::Perl;
  21
  22 use Carp;
  23 use Data::Dumper;
  24 use List::MoreUtils qw( uniq );
  25
  26 use C4::Circulation qw( ReturnLostItem );
  27 use C4::Letters;
  28 use C4::Log qw( logaction );
  29 use C4::Stats qw( UpdateStats );
  30
  31 use Koha::Patrons;
  32 use Koha::Account::Lines;
  33 use Koha::Account::Offsets;
  34 use Koha::DateUtils qw( dt_from_string );
  35
  36 =head1 NAME
  37
  38 Koha::Accounts - Module for managing payments and fees for patrons
  39
  40 =cut
  41
  42 sub new {
  43     my ( $class, $params ) = @_;
  44
  45     Carp::croak("No patron id passed in!") unless $params->{patron_id};
  46
  47     return bless( $params, $class );
  48 }
  49
  50 =head2 pay
  51
  52 This method allows payments to be made against fees/fines
  53
  54 Koha::Account->new( { patron_id => $borrowernumber } )->pay(
  55     {
  56         amount      => $amount,
  57         sip         => $sipmode,
  58         note        => $note,
  59         description => $description,
  60         library_id  => $branchcode,
  61         lines        => $lines, # Arrayref of Koha::Account::Line objects to pay
  62         account_type => $type,  # accounttype code
  63         offset_type => $offset_type,    # offset type code
  64     }
  65 );
  66
  67 =cut
  68
  69 sub pay {
  70     my ( $self, $params ) = @_;
  71
  72     my $amount       = $params->{amount};
  73     my $sip          = $params->{sip};
  74     my $description  = $params->{description};
  75     my $note         = $params->{note} || q{};
  76     my $library_id   = $params->{library_id};
  77     my $lines        = $params->{lines};
  78     my $type         = $params->{type} || 'payment';
  79     my $payment_type = $params->{payment_type} || undef;
  80     my $account_type = $params->{account_type};
  81     my $offset_type  = $params->{offset_type} || $type eq 'writeoff' ? 'Writeoff' : 'Payment';
  82
  83     my $userenv = C4::Context->userenv;
  84     $library_id ||= $userenv ? $userenv->{branch} : undef;
  85
  86     my $patron = Koha::Patrons->find( $self->{patron_id} );
  87
  88     # We should remove accountno, it is no longer needed
  89     my $last = $self->lines->search(
  90         {},
  91         { order_by => 'accountno' } )->next();
  92     my $accountno = $last ? $last->accountno + 1 : 1;
  93
  94     my $manager_id = $userenv ? $userenv->{number} : 0;
  95
  96     my @fines_paid; # List of account lines paid on with this payment
  97
  98     my $balance_remaining = $amount; # Set it now so we can adjust the amount if necessary
  99     $balance_remaining ||= 0;
 100
 101     my @account_offsets;
 102
 103     # We were passed a specific line to pay
 104     foreach my $fine ( @$lines ) {
 105         my $amount_to_pay =
 106             $fine->amountoutstanding > $balance_remaining
 107           ? $balance_remaining
 108           : $fine->amountoutstanding;
 109
 110         my $old_amountoutstanding = $fine->amountoutstanding;
 111         my $new_amountoutstanding = $old_amountoutstanding - $amount_to_pay;
 112         $fine->amountoutstanding($new_amountoutstanding)->store();
 113         $balance_remaining = $balance_remaining - $amount_to_pay;
 114
 115         if ( $fine->itemnumber && $fine->accounttype && ( $fine->accounttype eq 'Rep' || $fine->accounttype eq 'L' ) )
 116         {
 117             C4::Circulation::ReturnLostItem( $self->{patron_id}, $fine->itemnumber );
 118         }
 119
 120         my $account_offset = Koha::Account::Offset->new(
 121             {
 122                 debit_id => $fine->id,
 123                 type     => $offset_type,
 124                 amount   => $amount_to_pay * -1,
 125             }
 126         );
 127         push( @account_offsets, $account_offset );
 128
 129         if ( C4::Context->preference("FinesLog") ) {
 130             logaction(
 131                 "FINES", 'MODIFY',
 132                 $self->{patron_id},
 133                 Dumper(
 134                     {
 135                         action                => 'fee_payment',
 136                         borrowernumber        => $fine->borrowernumber,
 137                         old_amountoutstanding => $old_amountoutstanding,
 138                         new_amountoutstanding => 0,
 139                         amount_paid           => $old_amountoutstanding,
 140                         accountlines_id       => $fine->id,
 141                         accountno             => $fine->accountno,
 142                         manager_id            => $manager_id,
 143                         note                  => $note,
 144                     }
 145                 )
 146             );
 147             push( @fines_paid, $fine->id );
 148         }
 149     }
 150
 151     # Were not passed a specific line to pay, or the payment was for more
 152     # than the what was owed on the given line. In that case pay down other
 153     # lines with remaining balance.
 154     my @outstanding_fines;
 155     @outstanding_fines = $self->lines->search(
 156         {
 157             amountoutstanding => { '>' => 0 },
 158         }
 159     ) if $balance_remaining > 0;
 160
 161     foreach my $fine (@outstanding_fines) {
 162         my $amount_to_pay =
 163             $fine->amountoutstanding > $balance_remaining
 164           ? $balance_remaining
 165           : $fine->amountoutstanding;
 166
 167         my $old_amountoutstanding = $fine->amountoutstanding;
 168         $fine->amountoutstanding( $old_amountoutstanding - $amount_to_pay );
 169         $fine->store();
 170
 171         my $account_offset = Koha::Account::Offset->new(
 172             {
 173                 debit_id => $fine->id,
 174                 type     => $offset_type,
 175                 amount   => $amount_to_pay * -1,
 176             }
 177         );
 178         push( @account_offsets, $account_offset );
 179
 180         if ( C4::Context->preference("FinesLog") ) {
 181             logaction(
 182                 "FINES", 'MODIFY',
 183                 $self->{patron_id},
 184                 Dumper(
 185                     {
 186                         action                => "fee_$type",
 187                         borrowernumber        => $fine->borrowernumber,
 188                         old_amountoutstanding => $old_amountoutstanding,
 189                         new_amountoutstanding => $fine->amountoutstanding,
 190                         amount_paid           => $amount_to_pay,
 191                         accountlines_id       => $fine->id,
 192                         accountno             => $fine->accountno,
 193                         manager_id            => $manager_id,
 194                         note                  => $note,
 195                     }
 196                 )
 197             );
 198             push( @fines_paid, $fine->id );
 199         }
 200
 201         $balance_remaining = $balance_remaining - $amount_to_pay;
 202         last unless $balance_remaining > 0;
 203     }
 204
 205     $account_type ||=
 206         $type eq 'writeoff' ? 'W'
 207       : defined($sip)       ? "Pay$sip"
 208       :                       'Pay';
 209
 210     $description ||= $type eq 'writeoff' ? 'Writeoff' : q{};
 211
 212     my $payment = Koha::Account::Line->new(
 213         {
 214             borrowernumber    => $self->{patron_id},
 215             accountno         => $accountno,
 216             date              => dt_from_string(),
 217             amount            => 0 - $amount,
 218             description       => $description,
 219             accounttype       => $account_type,
 220             payment_type      => $payment_type,
 221             amountoutstanding => 0 - $balance_remaining,
 222             manager_id        => $manager_id,
 223             branchcode        => $library_id,
 224             note              => $note,
 225         }
 226     )->store();
 227
 228     foreach my $o ( @account_offsets ) {
 229         $o->credit_id( $payment->id() );
 230         $o->store();
 231     }
 232
 233     UpdateStats(
 234         {
 235             branch         => $library_id,
 236             type           => $type,
 237             amount         => $amount,
 238             borrowernumber => $self->{patron_id},
 239             accountno      => $accountno,
 240         }
 241     );
 242
 243     if ( C4::Context->preference("FinesLog") ) {
 244         logaction(
 245             "FINES", 'CREATE',
 246             $self->{patron_id},
 247             Dumper(
 248                 {
 249                     action            => "create_$type",
 250                     borrowernumber    => $self->{patron_id},
 251                     accountno         => $accountno,
 252                     amount            => 0 - $amount,
 253                     amountoutstanding => 0 - $balance_remaining,
 254                     accounttype       => $account_type,
 255                     accountlines_paid => \@fines_paid,
 256                     manager_id        => $manager_id,
 257                 }
 258             )
 259         );
 260     }
 261
 262     if ( C4::Context->preference('UseEmailReceipts') ) {
 263         if (
 264             my $letter = C4::Letters::GetPreparedLetter(
 265                 module                 => 'circulation',
 266                 letter_code            => uc("ACCOUNT_$type"),
 267                 message_transport_type => 'email',
 268                 lang    => $patron->lang,
 269                 tables => {
 270                     borrowers       => $self->{patron_id},
 271                     branches        => $self->{library_id},
 272                 },
 273                 substitute => {
 274                     credit => $payment,
 275                     offsets => \@account_offsets,
 276                 },
 277               )
 278           )
 279         {
 280             C4::Letters::EnqueueLetter(
 281                 {
 282                     letter                 => $letter,
 283                     borrowernumber         => $self->{patron_id},
 284                     message_transport_type => 'email',
 285                 }
 286             ) or warn "can't enqueue letter $letter";
 287         }
 288     }
 289
 290     return $payment->id;
 291 }
 292
 293 =head3 add_credit
 294
 295 This method allows adding credits to a patron's account
 296
 297 my $credit_line = Koha::Account->new({ patron_id => $patron_id })->add_credit(
 298     {
 299         amount       => $amount,
 300         description  => $description,
 301         note         => $note,
 302         user_id      => $user_id,
 303         library_id   => $library_id,
 304         sip          => $sip,
 305         payment_type => $payment_type,
 306         type         => $credit_type,
 307         item_id      => $item_id
 308     }
 309 );
 310
 311 $credit_type can be any of:
 312   - 'credit'
 313   - 'payment'
 314   - 'forgiven'
 315   - 'lost_item_return'
 316   - 'writeoff'
 317
 318 =cut
 319
 320 sub add_credit {
 321
 322     my ( $self, $params ) = @_;
 323
 324     # amount is passed as a positive value, but we store credit as negative values
 325     my $amount       = $params->{amount} * -1;
 326     my $description  = $params->{description} // q{};
 327     my $note         = $params->{note} // q{};
 328     my $user_id      = $params->{user_id};
 329     my $library_id   = $params->{library_id};
 330     my $sip          = $params->{sip};
 331     my $payment_type = $params->{payment_type};
 332     my $type         = $params->{type} || 'payment';
 333     my $item_id      = $params->{item_id};
 334
 335     my $schema = Koha::Database->new->schema;
 336
 337     my $account_type = $Koha::Account::account_type->{$type};
 338     $account_type .= $sip
 339         if defined $sip &&
 340            $type eq 'payment';
 341
 342     my $line;
 343
 344     $schema->txn_do(
 345         sub {
 346             # We should remove accountno, it is no longer needed
 347             my $last = $self->lines->search(
 348                 {},
 349                 { order_by => 'accountno' } )->next();
 350             my $accountno = $last ? $last->accountno + 1 : 1;
 351
 352             # Insert the account line
 353             $line = Koha::Account::Line->new(
 354                 {   borrowernumber    => $self->{patron_id},
 355                     accountno         => $accountno,
 356                     date              => \'NOW()',
 357                     amount            => $amount,
 358                     description       => $description,
 359                     accounttype       => $account_type,
 360                     amountoutstanding => $amount,
 361                     payment_type      => $payment_type,
 362                     note              => $note,
 363                     manager_id        => $user_id,
 364                     branchcode        => $library_id,
 365                     itemnumber        => $item_id,
 366                     lastincrement     => undef,
 367                 }
 368             )->store();
 369
 370             # Record the account offset
 371             my $account_offset = Koha::Account::Offset->new(
 372                 {   credit_id => $line->id,
 373                     type      => $Koha::Account::offset_type->{$type},
 374                     amount    => $amount
 375                 }
 376             )->store();
 377
 378             UpdateStats(
 379                 {   branch         => $library_id,
 380                     type           => $type,
 381                     amount         => $amount,
 382                     borrowernumber => $self->{patron_id},
 383                     accountno      => $accountno,
 384                 }
 385             ) if grep { $type eq $_ } ('payment', 'writeoff') ;
 386
 387             if ( C4::Context->preference("FinesLog") ) {
 388                 logaction(
 389                     "FINES", 'CREATE',
 390                     $self->{patron_id},
 391                     Dumper(
 392                         {   action            => "create_$type",
 393                             borrowernumber    => $self->{patron_id},
 394                             accountno         => $accountno,
 395                             amount            => $amount,
 396                             description       => $description,
 397                             amountoutstanding => $amount,
 398                             accounttype       => $account_type,
 399                             note              => $note,
 400                             itemnumber        => $item_id,
 401                             manager_id        => $user_id,
 402                             branchcode        => $library_id,
 403                         }
 404                     )
 405                 );
 406             }
 407         }
 408     );
 409
 410     return $line;
 411 }
 412
 413 =head3 balance
 414
 415 my $balance = $self->balance
 416
 417 Return the balance (sum of amountoutstanding columns)
 418
 419 =cut
 420
 421 sub balance {
 422     my ($self) = @_;
 423     return $self->lines->total_outstanding;
 424 }
 425
 426 =head3 outstanding_debits
 427
 428 my $lines = Koha::Account->new({ patron_id => $patron_id })->outstanding_debits;
 429
 430 It returns the debit lines with outstanding amounts for the patron.
 431
 432 In scalar context, it returns a Koha::Account::Lines iterator. In list context, it will
 433 return a list of Koha::Account::Line objects.
 434
 435 =cut
 436
 437 sub outstanding_debits {
 438     my ($self) = @_;
 439
 440     return $self->lines->search(
 441         {
 442             amount            => { '>' => 0 },
 443             amountoutstanding => { '>' => 0 }
 444         }
 445     );
 446 }
 447
 448 =head3 outstanding_credits
 449
 450 my $lines = Koha::Account->new({ patron_id => $patron_id })->outstanding_credits;
 451
 452 It returns the credit lines with outstanding amounts for the patron.
 453
 454 In scalar context, it returns a Koha::Account::Lines iterator. In list context, it will
 455 return a list of Koha::Account::Line objects.
 456
 457 =cut
 458
 459 sub outstanding_credits {
 460     my ($self) = @_;
 461
 462     return $self->lines->search(
 463         {
 464             amount            => { '<' => 0 },
 465             amountoutstanding => { '<' => 0 }
 466         }
 467     );
 468 }
 469
 470 =head3 non_issues_charges
 471
 472 my $non_issues_charges = $self->non_issues_charges
 473
 474 Calculates amount immediately owing by the patron - non-issue charges.
 475
 476 Charges exempt from non-issue are:
 477 * Res (holds) if HoldsInNoissuesCharge syspref is set to false
 478 * Rent (rental) if RentalsInNoissuesCharge syspref is set to false
 479 * Manual invoices if ManInvInNoissuesCharge syspref is set to false
 480
 481 =cut
 482
 483 sub non_issues_charges {
 484     my ($self) = @_;
 485
 486     # FIXME REMOVE And add a warning in the about page + update DB if length(MANUAL_INV) > 5
 487     my $ACCOUNT_TYPE_LENGTH = 5;    # this is plain ridiculous...
 488
 489     my @not_fines;
 490     push @not_fines, 'Res'
 491       unless C4::Context->preference('HoldsInNoissuesCharge');
 492     push @not_fines, 'Rent'
 493       unless C4::Context->preference('RentalsInNoissuesCharge');
 494     unless ( C4::Context->preference('ManInvInNoissuesCharge') ) {
 495         my $dbh = C4::Context->dbh;
 496         push @not_fines,
 497           @{
 498             $dbh->selectcol_arrayref(q|
 499                 SELECT authorised_value FROM authorised_values WHERE category = 'MANUAL_INV'
 500             |)
 501           };
 502     }
 503     @not_fines = map { substr( $_, 0, $ACCOUNT_TYPE_LENGTH ) } uniq(@not_fines);
 504
 505     return $self->lines->search(
 506         {
 507             accounttype    => { -not_in => \@not_fines }
 508         },
 509     )->total_outstanding;
 510 }
 511
 512 =head3 lines
 513
 514 my $lines = $self->lines;
 515
 516 Return all credits and debits for the user, outstanding or otherwise
 517
 518 =cut
 519
 520 sub lines {
 521     my ($self) = @_;
 522
 523     return Koha::Account::Lines->search(
 524         {
 525             borrowernumber => $self->{patron_id},
 526         }
 527     );
 528 }
 529
 530 =head3 reconcile_balance
 531
 532 $account->reconcile_balance();
 533
 534 Find outstanding credits and use them to pay outstanding debits.
 535 Currently, this implicitly uses the 'First In First Out' rule for
 536 applying credits against debits.
 537
 538 =cut
 539
 540 sub reconcile_balance {
 541     my ($self) = @_;
 542
 543     my $outstanding_debits  = $self->outstanding_debits;
 544     my $outstanding_credits = $self->outstanding_credits;
 545
 546     while (     $outstanding_debits->total_outstanding > 0
 547             and my $credit = $outstanding_credits->next )
 548     {
 549         # there's both outstanding debits and credits
 550         $credit->apply( { debits => $outstanding_debits } );    # applying credit, no special offset
 551
 552         $outstanding_debits = $self->outstanding_debits;
 553
 554     }
 555
 556     return $self;
 557 }
 558
 559 1;
 560
 561 =head2 Name mappings
 562
 563 =head3 $offset_type
 564
 565 =cut
 566
 567 our $offset_type = {
 568     'credit'           => 'Manual Credit',
 569     'forgiven'         => 'Writeoff',
 570     'lost_item_return' => 'Lost Item',
 571     'payment'          => 'Payment',
 572     'writeoff'         => 'Writeoff'
 573 };
 574
 575 =head3 $account_type
 576
 577 =cut
 578
 579 our $account_type = {
 580     'credit'           => 'C',
 581     'forgiven'         => 'FOR',
 582     'lost_item_return' => 'CR',
 583     'payment'          => 'Pay',
 584     'writeoff'         => 'W'
 585 };
 586
 587 =head1 AUTHOR
 588
 589 Kyle M Hall <kyle.m.hall@gmail.com>
 590
 591 =cut