Koha/Account/Line.pm

   1 package Koha::Account::Line;
   2
   3 # This file is part of Koha.
   4 #
   5 # Koha is free software; you can redistribute it and/or modify it under the
   6 # terms of the GNU General Public License as published by the Free Software
   7 # Foundation; either version 3 of the License, or (at your option) any later
   8 # version.
   9 #
  10 # Koha is distributed in the hope that it will be useful, but WITHOUT ANY
  11 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  12 # A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License along
  15 # with Koha; if not, write to the Free Software Foundation, Inc.,
  16 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17
  18 use Modern::Perl;
  19
  20 use Carp;
  21 use Data::Dumper;
  22
  23 use C4::Log qw(logaction);
  24
  25 use Koha::Account::Offsets;
  26 use Koha::Database;
  27 use Koha::Exceptions::Account;
  28 use Koha::Items;
  29
  30 use base qw(Koha::Object);
  31
  32 =head1 NAME
  33
  34 Koha::Account::Lines - Koha accountline Object class
  35
  36 =head1 API
  37
  38 =head2 Class methods
  39
  40 =cut
  41
  42 =head3 item
  43
  44 Return the item linked to this account line if exists
  45
  46 =cut
  47
  48 sub item {
  49     my ( $self ) = @_;
  50     my $rs = $self->_result->itemnumber;
  51     return Koha::Item->_new_from_dbic( $rs );
  52 }
  53
  54 =head3 void
  55
  56 $payment_accountline->void();
  57
  58 =cut
  59
  60 sub void {
  61     my ($self) = @_;
  62
  63     # Make sure it is a payment we are voiding
  64     return unless $self->amount < 0;
  65
  66     my @account_offsets =
  67       Koha::Account::Offsets->search(
  68         { credit_id => $self->id, amount => { '<' => 0 }  } );
  69
  70     $self->_result->result_source->schema->txn_do(
  71         sub {
  72             foreach my $account_offset (@account_offsets) {
  73                 my $fee_paid =
  74                   Koha::Account::Lines->find( $account_offset->debit_id );
  75
  76                 next unless $fee_paid;
  77
  78                 my $amount_paid = $account_offset->amount * -1; # amount paid is stored as a negative amount
  79                 my $new_amount = $fee_paid->amountoutstanding + $amount_paid;
  80                 $fee_paid->amountoutstanding($new_amount);
  81                 $fee_paid->store();
  82
  83                 Koha::Account::Offset->new(
  84                     {
  85                         credit_id => $self->id,
  86                         debit_id  => $fee_paid->id,
  87                         amount    => $amount_paid,
  88                         type      => 'Void Payment',
  89                     }
  90                 )->store();
  91             }
  92
  93             if ( C4::Context->preference("FinesLog") ) {
  94                 logaction(
  95                     "FINES", 'VOID',
  96                     $self->borrowernumber,
  97                     Dumper(
  98                         {
  99                             action         => 'void_payment',
 100                             borrowernumber => $self->borrowernumber,
 101                             amount            => $self->amount,
 102                             amountoutstanding => $self->amountoutstanding,
 103                             description       => $self->description,
 104                             accounttype       => $self->accounttype,
 105                             payment_type      => $self->payment_type,
 106                             note              => $self->note,
 107                             itemnumber        => $self->itemnumber,
 108                             manager_id        => $self->manager_id,
 109                             offsets =>
 110                               [ map { $_->unblessed } @account_offsets ],
 111                         }
 112                     )
 113                 );
 114             }
 115
 116             $self->set(
 117                 {
 118                     accounttype       => 'VOID',
 119                     amountoutstanding => 0,
 120                     amount            => 0,
 121                 }
 122             );
 123             $self->store();
 124         }
 125     );
 126
 127 }
 128
 129 =head3 apply
 130
 131     my $outstanding_amount = $credit->apply({ debit =>  $debit, [ offset_type => $offset_type ] });
 132
 133 =cut
 134
 135 sub apply {
 136     my ( $self, $params ) = @_;
 137
 138     my $debit       = $params->{debit};
 139     my $offset_type = $params->{offset_type} // 'credit_applied';
 140
 141     unless ( $self->is_credit ) {
 142         Koha::Exceptions::Account::IsNotCredit->throw(
 143             error => 'Account line ' . $self->id . ' is not a credit'
 144         );
 145     }
 146
 147     unless ( $debit->is_debit ) {
 148         Koha::Exceptions::Account::IsNotDebit->throw(
 149             error => 'Account line ' . $debit->id . 'is not a debit'
 150         );
 151     }
 152
 153     my $available_credit = $self->amountoutstanding * -1;
 154
 155     unless ( $available_credit > 0 ) {
 156         Koha::Exceptions::Account::NoAvailableCredit->throw(
 157             error => 'Outstanding credit is ' . $available_credit . ' and cannot be applied'
 158         );
 159     }
 160
 161     my $schema = Koha::Database->new->schema;
 162
 163     $schema->txn_do( sub {
 164
 165         my $amount_to_cancel;
 166         my $owed = $debit->amountoutstanding;
 167
 168         if ( $available_credit >= $owed ) {
 169             $amount_to_cancel = $owed;
 170         }
 171         else {    # $available_credit < $debit->amountoutstanding
 172             $amount_to_cancel = $available_credit;
 173         }
 174
 175         # record the account offset
 176         Koha::Account::Offset->new(
 177             {   credit_id => $self->id,
 178                 debit_id  => $debit->id,
 179                 amount    => $amount_to_cancel,
 180                 type      => $offset_type,
 181             }
 182         )->store();
 183
 184         $available_credit -= $amount_to_cancel;
 185
 186         $self->amountoutstanding( $available_credit * -1 )->store;
 187         $debit->amountoutstanding( $owed - $amount_to_cancel )->store;
 188     });
 189
 190     return $available_credit;
 191 }
 192
 193 =head3 is_credit
 194
 195     my $bool = $line->is_credit;
 196
 197 =cut
 198
 199 sub is_credit {
 200     my ($self) = @_;
 201
 202     return ( $self->amount < 0 );
 203 }
 204
 205 =head3 is_debit
 206
 207     my $bool = $line->is_debit;
 208
 209 =cut
 210
 211 sub is_debit {
 212     my ($self) = @_;
 213
 214     return !$self->is_credit;
 215 }
 216
 217 =head2 Internal methods
 218
 219 =cut
 220
 221 =head3 _type
 222
 223 =cut
 224
 225 sub _type {
 226     return 'Accountline';
 227 }
 228
 229 1;