Bug 20400: Fix get_routing_lists tests
[koha.git] / 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 non_issues_charges
292
293 my $non_issues_charges = $self->non_issues_charges
294
295 Calculates amount immediately owing by the patron - non-issue charges.
296
297 Charges exempt from non-issue are:
298 * Res (holds) if HoldsInNoissuesCharge syspref is set to false
299 * Rent (rental) if RentalsInNoissuesCharge syspref is set to false
300 * Manual invoices if ManInvInNoissuesCharge syspref is set to false
301
302 =cut
303
304 sub non_issues_charges {
305     my ($self) = @_;
306
307     # FIXME REMOVE And add a warning in the about page + update DB if length(MANUAL_INV) > 5
308     my $ACCOUNT_TYPE_LENGTH = 5;    # this is plain ridiculous...
309
310     my @not_fines;
311     push @not_fines, 'Res'
312       unless C4::Context->preference('HoldsInNoissuesCharge');
313     push @not_fines, 'Rent'
314       unless C4::Context->preference('RentalsInNoissuesCharge');
315     unless ( C4::Context->preference('ManInvInNoissuesCharge') ) {
316         my $dbh = C4::Context->dbh;
317         push @not_fines,
318           @{
319             $dbh->selectcol_arrayref(q|
320                 SELECT authorised_value FROM authorised_values WHERE category = 'MANUAL_INV'
321             |)
322           };
323     }
324     @not_fines = map { substr( $_, 0, $ACCOUNT_TYPE_LENGTH ) } uniq(@not_fines);
325
326     my $non_issues_charges = Koha::Account::Lines->search(
327         {
328             borrowernumber => $self->{patron_id},
329             accounttype    => { -not_in => \@not_fines }
330         },
331         {
332             select => [ { sum => 'amountoutstanding' } ],
333             as     => ['non_issues_charges'],
334         }
335     );
336     return $non_issues_charges->count
337       ? $non_issues_charges->next->get_column('non_issues_charges') + 0
338       : 0;
339 }
340
341 1;
342
343 =head1 AUTHOR
344
345 Kyle M Hall <kyle.m.hall@gmail.com>
346
347 =cut