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 use List::Util qw( sum );
  26
  27 use C4::Log qw( logaction );
  28 use C4::Stats qw( UpdateStats );
  29
  30 use Koha::Account::Lines;
  31 use Koha::Account::Offsets;
  32 use Koha::DateUtils qw( dt_from_string );
  33
  34 =head1 NAME
  35
  36 Koha::Accounts - Module for managing payments and fees for patrons
  37
  38 =cut
  39
  40 sub new {
  41     my ( $class, $params ) = @_;
  42
  43     Carp::croak("No patron id passed in!") unless $params->{patron_id};
  44
  45     return bless( $params, $class );
  46 }
  47
  48 =head2 pay
  49
  50 This method allows payments to be made against fees/fines
  51
  52 Koha::Account->new( { patron_id => $borrowernumber } )->pay(
  53     {
  54         amount      => $amount,
  55         sip         => $sipmode,
  56         note        => $note,
  57         description => $description,
  58         library_id  => $branchcode,
  59         lines        => $lines, # Arrayref of Koha::Account::Line objects to pay
  60         account_type => $type,  # accounttype code
  61         offset_type => $offset_type,    # offset type code
  62     }
  63 );
  64
  65 =cut
  66
  67 sub pay {
  68     my ( $self, $params ) = @_;
  69
  70     my $amount       = $params->{amount};
  71     my $sip          = $params->{sip};
  72     my $description  = $params->{description};
  73     my $note         = $params->{note} || q{};
  74     my $library_id   = $params->{library_id};
  75     my $lines        = $params->{lines};
  76     my $type         = $params->{type} || 'payment';
  77     my $payment_type = $params->{payment_type} || undef;
  78     my $account_type = $params->{account_type};
  79     my $offset_type  = $params->{offset_type} || $type eq 'writeoff' ? 'Writeoff' : 'Payment';
  80
  81     my $userenv = C4::Context->userenv;
  82
  83     # We should remove accountno, it is no longer needed
  84     my $last = Koha::Account::Lines->search(
  85         {
  86             borrowernumber => $self->{patron_id}
  87         },
  88         {
  89             order_by => 'accountno'
  90         }
  91     )->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 = Koha::Account::Lines->search(
 156         {
 157             borrowernumber    => $self->{patron_id},
 158             amountoutstanding => { '>' => 0 },
 159         }
 160     ) if $balance_remaining > 0;
 161
 162     foreach my $fine (@outstanding_fines) {
 163         my $amount_to_pay =
 164             $fine->amountoutstanding > $balance_remaining
 165           ? $balance_remaining
 166           : $fine->amountoutstanding;
 167
 168         my $old_amountoutstanding = $fine->amountoutstanding;
 169         $fine->amountoutstanding( $old_amountoutstanding - $amount_to_pay );
 170         $fine->store();
 171
 172         my $account_offset = Koha::Account::Offset->new(
 173             {
 174                 debit_id => $fine->id,
 175                 type     => $offset_type,
 176                 amount   => $amount_to_pay * -1,
 177             }
 178         );
 179         push( @account_offsets, $account_offset );
 180
 181         if ( C4::Context->preference("FinesLog") ) {
 182             logaction(
 183                 "FINES", 'MODIFY',
 184                 $self->{patron_id},
 185                 Dumper(
 186                     {
 187                         action                => "fee_$type",
 188                         borrowernumber        => $fine->borrowernumber,
 189                         old_amountoutstanding => $old_amountoutstanding,
 190                         new_amountoutstanding => $fine->amountoutstanding,
 191                         amount_paid           => $amount_to_pay,
 192                         accountlines_id       => $fine->id,
 193                         accountno             => $fine->accountno,
 194                         manager_id            => $manager_id,
 195                         note                  => $note,
 196                     }
 197                 )
 198             );
 199             push( @fines_paid, $fine->id );
 200         }
 201
 202         $balance_remaining = $balance_remaining - $amount_to_pay;
 203         last unless $balance_remaining > 0;
 204     }
 205
 206     $account_type ||=
 207         $type eq 'writeoff' ? 'W'
 208       : defined($sip)       ? "Pay$sip"
 209       :                       'Pay';
 210
 211     $description ||= $type eq 'writeoff' ? 'Writeoff' : q{};
 212
 213     my $payment = Koha::Account::Line->new(
 214         {
 215             borrowernumber    => $self->{patron_id},
 216             accountno         => $accountno,
 217             date              => dt_from_string(),
 218             amount            => 0 - $amount,
 219             description       => $description,
 220             accounttype       => $account_type,
 221             payment_type      => $payment_type,
 222             amountoutstanding => 0 - $balance_remaining,
 223             manager_id        => $manager_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     $library_id ||= $userenv ? $userenv->{'branch'} : undef;
 234
 235     UpdateStats(
 236         {
 237             branch         => $library_id,
 238             type           => $type,
 239             amount         => $amount,
 240             borrowernumber => $self->{patron_id},
 241             accountno      => $accountno,
 242         }
 243     );
 244
 245     if ( C4::Context->preference("FinesLog") ) {
 246         logaction(
 247             "FINES", 'CREATE',
 248             $self->{patron_id},
 249             Dumper(
 250                 {
 251                     action            => "create_$type",
 252                     borrowernumber    => $self->{patron_id},
 253                     accountno         => $accountno,
 254                     amount            => 0 - $amount,
 255                     amountoutstanding => 0 - $balance_remaining,
 256                     accounttype       => $account_type,
 257                     accountlines_paid => \@fines_paid,
 258                     manager_id        => $manager_id,
 259                 }
 260             )
 261         );
 262     }
 263
 264     return $payment->id;
 265 }
 266
 267 =head3 balance
 268
 269 my $balance = $self->balance
 270
 271 Return the balance (sum of amountoutstanding columns)
 272
 273 =cut
 274
 275 sub balance {
 276     my ($self) = @_;
 277     my $fines = Koha::Account::Lines->search(
 278         {
 279             borrowernumber => $self->{patron_id},
 280         },
 281         {
 282             select => [ { sum => 'amountoutstanding' } ],
 283             as => ['total_amountoutstanding'],
 284         }
 285     );
 286
 287     return ( $fines->count )
 288       ? $fines->next->get_column('total_amountoutstanding') + 0
 289       : 0;
 290 }
 291
 292 =head3 outstanding_debits
 293
 294 my ( $total, $lines ) = Koha::Account->new({ patron_id => $patron_id })->outstanding_debits;
 295
 296 =cut
 297
 298 sub outstanding_debits {
 299     my ($self) = @_;
 300
 301     my $lines = Koha::Account::Lines->search(
 302         {
 303             borrowernumber    => $self->{patron_id},
 304             amountoutstanding => { '>' => 0 }
 305         }
 306     );
 307
 308     # sum returns undef it list is empty
 309     my $total = sum( $lines->get_column('amountoutstanding') ) + 0;
 310
 311     return ( $total, $lines );
 312 }
 313
 314 =head3 non_issues_charges
 315
 316 my $non_issues_charges = $self->non_issues_charges
 317
 318 Calculates amount immediately owing by the patron - non-issue charges.
 319
 320 Charges exempt from non-issue are:
 321 * Res (holds) if HoldsInNoissuesCharge syspref is set to false
 322 * Rent (rental) if RentalsInNoissuesCharge syspref is set to false
 323 * Manual invoices if ManInvInNoissuesCharge syspref is set to false
 324
 325 =cut
 326
 327 sub non_issues_charges {
 328     my ($self) = @_;
 329
 330     # FIXME REMOVE And add a warning in the about page + update DB if length(MANUAL_INV) > 5
 331     my $ACCOUNT_TYPE_LENGTH = 5;    # this is plain ridiculous...
 332
 333     my @not_fines;
 334     push @not_fines, 'Res'
 335       unless C4::Context->preference('HoldsInNoissuesCharge');
 336     push @not_fines, 'Rent'
 337       unless C4::Context->preference('RentalsInNoissuesCharge');
 338     unless ( C4::Context->preference('ManInvInNoissuesCharge') ) {
 339         my $dbh = C4::Context->dbh;
 340         push @not_fines,
 341           @{
 342             $dbh->selectcol_arrayref(q|
 343                 SELECT authorised_value FROM authorised_values WHERE category = 'MANUAL_INV'
 344             |)
 345           };
 346     }
 347     @not_fines = map { substr( $_, 0, $ACCOUNT_TYPE_LENGTH ) } uniq(@not_fines);
 348
 349     my $non_issues_charges = Koha::Account::Lines->search(
 350         {
 351             borrowernumber => $self->{patron_id},
 352             accounttype    => { -not_in => \@not_fines }
 353         },
 354         {
 355             select => [ { sum => 'amountoutstanding' } ],
 356             as     => ['non_issues_charges'],
 357         }
 358     );
 359     return $non_issues_charges->count
 360       ? $non_issues_charges->next->get_column('non_issues_charges') + 0
 361       : 0;
 362 }
 363
 364 1;
 365
 366 =head1 AUTHOR
 367
 368 Kyle M Hall <kyle.m.hall@gmail.com>
 369
 370 =cut