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::Log qw( logaction );
  27 use C4::Stats qw( UpdateStats );
  28
  29 use Koha::Account::Lines;
  30 use Koha::Account::Offsets;
  31 use Koha::DateUtils qw( dt_from_string );
  32
  33 =head1 NAME
  34
  35 Koha::Accounts - Module for managing payments and fees for patrons
  36
  37 =cut
  38
  39 sub new {
  40     my ( $class, $params ) = @_;
  41
  42     Carp::croak("No patron id passed in!") unless $params->{patron_id};
  43
  44     return bless( $params, $class );
  45 }
  46
  47 =head2 pay
  48
  49 This method allows payments to be made against fees/fines
  50
  51 Koha::Account->new( { patron_id => $borrowernumber } )->pay(
  52     {
  53         amount      => $amount,
  54         sip         => $sipmode,
  55         note        => $note,
  56         description => $description,
  57         library_id  => $branchcode,
  58         lines        => $lines, # Arrayref of Koha::Account::Line objects to pay
  59         account_type => $type,  # accounttype code
  60         offset_type => $offset_type,    # offset type code
  61     }
  62 );
  63
  64 =cut
  65
  66 sub pay {
  67     my ( $self, $params ) = @_;
  68
  69     my $amount       = $params->{amount};
  70     my $sip          = $params->{sip};
  71     my $description  = $params->{description};
  72     my $note         = $params->{note} || q{};
  73     my $library_id   = $params->{library_id};
  74     my $lines        = $params->{lines};
  75     my $type         = $params->{type} || 'payment';
  76     my $payment_type = $params->{payment_type} || undef;
  77     my $account_type = $params->{account_type};
  78     my $offset_type  = $params->{offset_type} || $type eq 'writeoff' ? 'Writeoff' : 'Payment';
  79
  80     my $userenv = C4::Context->userenv;
  81
  82     # We should remove accountno, it is no longer needed
  83     my $last = Koha::Account::Lines->search(
  84         {
  85             borrowernumber => $self->{patron_id}
  86         },
  87         {
  88             order_by => 'accountno'
  89         }
  90     )->next();
  91     my $accountno = $last ? $last->accountno + 1 : 1;
  92
  93     my $manager_id = $userenv ? $userenv->{number} : 0;
  94
  95     my @fines_paid; # List of account lines paid on with this payment
  96
  97     my $balance_remaining = $amount; # Set it now so we can adjust the amount if necessary
  98     $balance_remaining ||= 0;
  99
 100     my @account_offsets;
 101
 102     # We were passed a specific line to pay
 103     foreach my $fine ( @$lines ) {
 104         my $amount_to_pay =
 105             $fine->amountoutstanding > $balance_remaining
 106           ? $balance_remaining
 107           : $fine->amountoutstanding;
 108
 109         my $old_amountoutstanding = $fine->amountoutstanding;
 110         my $new_amountoutstanding = $old_amountoutstanding - $amount_to_pay;
 111         $fine->amountoutstanding($new_amountoutstanding)->store();
 112         $balance_remaining = $balance_remaining - $amount_to_pay;
 113
 114         if ( $fine->itemnumber && $fine->accounttype && ( $fine->accounttype eq 'Rep' || $fine->accounttype eq 'L' ) )
 115         {
 116             C4::Circulation::ReturnLostItem( $self->{patron_id}, $fine->itemnumber );
 117         }
 118
 119         my $account_offset = Koha::Account::Offset->new(
 120             {
 121                 debit_id => $fine->id,
 122                 type     => $offset_type,
 123                 amount   => $amount_to_pay * -1,
 124             }
 125         );
 126         push( @account_offsets, $account_offset );
 127
 128         if ( C4::Context->preference("FinesLog") ) {
 129             logaction(
 130                 "FINES", 'MODIFY',
 131                 $self->{patron_id},
 132                 Dumper(
 133                     {
 134                         action                => 'fee_payment',
 135                         borrowernumber        => $fine->borrowernumber,
 136                         old_amountoutstanding => $old_amountoutstanding,
 137                         new_amountoutstanding => 0,
 138                         amount_paid           => $old_amountoutstanding,
 139                         accountlines_id       => $fine->id,
 140                         accountno             => $fine->accountno,
 141                         manager_id            => $manager_id,
 142                         note                  => $note,
 143                     }
 144                 )
 145             );
 146             push( @fines_paid, $fine->id );
 147         }
 148     }
 149
 150     # Were not passed a specific line to pay, or the payment was for more
 151     # than the what was owed on the given line. In that case pay down other
 152     # lines with remaining balance.
 153     my @outstanding_fines;
 154     @outstanding_fines = Koha::Account::Lines->search(
 155         {
 156             borrowernumber    => $self->{patron_id},
 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             note              => $note,
 224         }
 225     )->store();
 226
 227     foreach my $o ( @account_offsets ) {
 228         $o->credit_id( $payment->id() );
 229         $o->store();
 230     }
 231
 232     $library_id ||= $userenv ? $userenv->{'branch'} : undef;
 233
 234     UpdateStats(
 235         {
 236             branch         => $library_id,
 237             type           => $type,
 238             amount         => $amount,
 239             borrowernumber => $self->{patron_id},
 240             accountno      => $accountno,
 241         }
 242     );
 243
 244     if ( C4::Context->preference("FinesLog") ) {
 245         logaction(
 246             "FINES", 'CREATE',
 247             $self->{patron_id},
 248             Dumper(
 249                 {
 250                     action            => "create_$type",
 251                     borrowernumber    => $self->{patron_id},
 252                     accountno         => $accountno,
 253                     amount            => 0 - $amount,
 254                     amountoutstanding => 0 - $balance_remaining,
 255                     accounttype       => $account_type,
 256                     accountlines_paid => \@fines_paid,
 257                     manager_id        => $manager_id,
 258                 }
 259             )
 260         );
 261     }
 262
 263     return $payment->id;
 264 }
 265
 266 =head3 balance
 267
 268 my $balance = $self->balance
 269
 270 Return the balance (sum of amountoutstanding columns)
 271
 272 =cut
 273
 274 sub balance {
 275     my ($self) = @_;
 276     my $fines = Koha::Account::Lines->search(
 277         {
 278             borrowernumber => $self->{patron_id},
 279         },
 280         {
 281             select => [ { sum => 'amountoutstanding' } ],
 282             as => ['total_amountoutstanding'],
 283         }
 284     );
 285
 286     return ( $fines->count )
 287       ? $fines->next->get_column('total_amountoutstanding') + 0
 288       : 0;
 289 }
 290
 291 =head3 outstanding_debits
 292
 293 my ( $total, $lines ) = Koha::Account->new({ patron_id => $patron_id })->outstanding_debits;
 294
 295 =cut
 296
 297 sub outstanding_debits {
 298     my ($self) = @_;
 299
 300     my $outstanding_debits = Koha::Account::Lines->search(
 301         {   borrowernumber    => $self->{patron_id},
 302             amountoutstanding => { '>' => 0 }
 303         },
 304         {   select => [ { sum => 'amountoutstanding' } ],
 305             as     => ['outstanding_debits_total'],
 306         }
 307     );
 308     my $total
 309         = ( $outstanding_debits->count )
 310         ? $outstanding_debits->next->get_column('outstanding_debits_total') + 0
 311         : 0;
 312
 313     my $lines = Koha::Account::Lines->search(
 314         {
 315             borrowernumber    => $self->{patron_id},
 316             amountoutstanding => { '>' => 0 }
 317         }
 318     );
 319
 320     return ( $total, $lines );
 321 }
 322
 323 =head3 non_issues_charges
 324
 325 my $non_issues_charges = $self->non_issues_charges
 326
 327 Calculates amount immediately owing by the patron - non-issue charges.
 328
 329 Charges exempt from non-issue are:
 330 * Res (holds) if HoldsInNoissuesCharge syspref is set to false
 331 * Rent (rental) if RentalsInNoissuesCharge syspref is set to false
 332 * Manual invoices if ManInvInNoissuesCharge syspref is set to false
 333
 334 =cut
 335
 336 sub non_issues_charges {
 337     my ($self) = @_;
 338
 339     # FIXME REMOVE And add a warning in the about page + update DB if length(MANUAL_INV) > 5
 340     my $ACCOUNT_TYPE_LENGTH = 5;    # this is plain ridiculous...
 341
 342     my @not_fines;
 343     push @not_fines, 'Res'
 344       unless C4::Context->preference('HoldsInNoissuesCharge');
 345     push @not_fines, 'Rent'
 346       unless C4::Context->preference('RentalsInNoissuesCharge');
 347     unless ( C4::Context->preference('ManInvInNoissuesCharge') ) {
 348         my $dbh = C4::Context->dbh;
 349         push @not_fines,
 350           @{
 351             $dbh->selectcol_arrayref(q|
 352                 SELECT authorised_value FROM authorised_values WHERE category = 'MANUAL_INV'
 353             |)
 354           };
 355     }
 356     @not_fines = map { substr( $_, 0, $ACCOUNT_TYPE_LENGTH ) } uniq(@not_fines);
 357
 358     my $non_issues_charges = Koha::Account::Lines->search(
 359         {
 360             borrowernumber => $self->{patron_id},
 361             accounttype    => { -not_in => \@not_fines }
 362         },
 363         {
 364             select => [ { sum => 'amountoutstanding' } ],
 365             as     => ['non_issues_charges'],
 366         }
 367     );
 368     return $non_issues_charges->count
 369       ? $non_issues_charges->next->get_column('non_issues_charges') + 0
 370       : 0;
 371 }
 372
 373 1;
 374
 375 =head1 AUTHOR
 376
 377 Kyle M Hall <kyle.m.hall@gmail.com>
 378
 379 =cut