Merge branch 'master' of git.evergreen-ils.org:Evergreen into template-toolkit-opac
[working/Evergreen.git] / Open-ILS / src / perlmods / lib / OpenILS / Application / Circ / Money.pm
1 # ---------------------------------------------------------------
2 # Copyright (C) 2005  Georgia Public Library Service 
3 # Bill Erickson <billserickson@gmail.com>
4
5 # This program is free software; you can redistribute it and/or
6 # modify it under the terms of the GNU General Public License
7 # as published by the Free Software Foundation; either version 2
8 # of the License, or (at your option) any later version.
9
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 # GNU General Public License for more details.
14 # ---------------------------------------------------------------
15
16 package OpenILS::Application::Circ::Money;
17 use base qw/OpenILS::Application/;
18 use strict; use warnings;
19 use OpenILS::Application::AppUtils;
20 my $apputils = "OpenILS::Application::AppUtils";
21 my $U = "OpenILS::Application::AppUtils";
22
23 use OpenSRF::EX qw(:try);
24 use OpenILS::Perm;
25 use Data::Dumper;
26 use OpenILS::Event;
27 use OpenSRF::Utils::Logger qw/:logger/;
28 use OpenILS::Utils::CStoreEditor qw/:funcs/;
29 use OpenILS::Utils::Penalty;
30 $Data::Dumper::Indent = 0;
31
32 __PACKAGE__->register_method(
33     method => "make_payments",
34     api_name => "open-ils.circ.money.payment",
35     signature => {
36         desc => q/Create payments for a given user and set of transactions,
37             login must have CREATE_PAYMENT privileges.
38             If any payments fail, all are reverted back./,
39         params => [
40             {desc => 'Authtoken', type => 'string'},
41             {desc => q/Arguments Hash, supporting the following params:
42                 { 
43                     payment_type
44                     userid
45                     patron_credit
46                     note
47                     cc_args: {
48                         where_process   1 to use processor, !1 for out-of-band
49                         approval_code   (for out-of-band payment)
50                         type            (for out-of-band payment)
51                         number          (for call to payment processor)
52                         expire_month    (for call to payment processor)
53                         expire_year     (for call to payment processor)
54                         billing_first   (for out-of-band payments and for call to payment processor)
55                         billing_last    (for out-of-band payments and for call to payment processor)
56                         billing_address (for call to payment processor)
57                         billing_city    (for call to payment processor)
58                         billing_state   (for call to payment processor)
59                         billing_zip     (for call to payment processor)
60                         note            (if payments->{note} is blank, use this)
61                     },
62                     check_number
63                     payments: [ 
64                         [trans_id, amt], 
65                         [...]
66                     ], 
67                 }/, type => 'hash'
68             },
69             {
70                 desc => q/Last user transaction ID.  This is the actor.usr.last_xact_id value/, 
71                 type => 'string'
72             }
73         ],
74         "return" => {
75             "desc" =>
76                 q{Array of payment IDs on success, event on failure.  Event possibilities include:
77                 BAD_PARAMS
78                     Bad parameters were given to this API method itself.
79                     See note field.
80                 INVALID_USER_XACT_ID
81                     The last user transaction ID does not match the ID in the database.  This means
82                     the user object has been updated since the last retrieval.  The client should
83                     be instructed to reload the user object and related transactions before attempting
84                     another payment
85                 REFUND_EXCEEDS_BALANCE
86                 REFUND_EXCEEDS_DESK_PAYMENTS
87                 CREDIT_PROCESSOR_NOT_SPECIFIED
88                     Evergreen has not been set up to process CC payments.
89                 CREDIT_PROCESSOR_NOT_ALLOWED
90                     Evergreen has been incorrectly setup for CC payments.
91                 CREDIT_PROCESSOR_NOT_ENABLED
92                     Evergreen has been set up for CC payments, but an admin
93                     has not explicitly enabled them.
94                 CREDIT_PROCESSOR_BAD_PARAMS
95                     Evergreen has been incorrectly setup for CC payments;
96                     specifically, the login and/or password for the CC
97                     processor weren't provided.
98                 CREDIT_PROCESSOR_INVALID_CC_NUMBER
99                     You have supplied a credit card number that Evergreen
100                     has judged to be invalid even before attempting to contact
101                     the payment processor.
102                 CREDIT_PROCESSOR_DECLINED_TRANSACTION
103                     We contacted the CC processor to attempt the charge, but
104                     they declined it.
105                         The error_message field of the event payload will
106                         contain the payment processor's response.  This
107                         typically includes a message in plain English intended
108                         for human consumption.  In PayPal's case, the message
109                         is preceded by an integer, a colon, and a space, so
110                         a caller might take the 2nd match from /^(\d+: )?(.+)$/
111                         to present to the user.
112                         The payload also contains other fields from the payment
113                         processor, but these are generally not user-friendly
114                         strings.
115                 CREDIT_PROCESSOR_SUCCESS_WO_RECORD
116                     A payment was processed successfully, but couldn't be
117                     recorded in Evergreen.  This is _bad bad bad_, as it means
118                     somebody made a payment but isn't getting credit for it.
119                     See errors in the system log if this happens.  Info from
120                     the credit card transaction will also be available in the
121                     event payload, although this probably won't be suitable for
122                     staff client/OPAC display.
123 },
124             "type" => "number"
125         }
126     }
127 );
128 sub make_payments {
129     my($self, $client, $auth, $payments, $last_xact_id) = @_;
130
131     my $e = new_editor(authtoken => $auth, xact => 1);
132     return $e->die_event unless $e->checkauth;
133
134     my $type = $payments->{payment_type};
135     my $user_id = $payments->{userid};
136     my $credit = $payments->{patron_credit} || 0;
137     my $drawer = $e->requestor->wsid;
138     my $note = $payments->{note};
139     my $cc_args = $payments->{cc_args};
140     my $check_number = $payments->{check_number};
141     my $total_paid = 0;
142     my $this_ou = $e->requestor->ws_ou || $e->requestor->home_ou;
143     my %orgs;
144
145     # unless/until determined by payment processor API
146     my ($approval_code, $cc_processor, $cc_type, $cc_order_number) = (undef,undef,undef, undef);
147
148     my $patron = $e->retrieve_actor_user($user_id) or return $e->die_event;
149
150     if($patron->last_xact_id ne $last_xact_id) {
151         $e->rollback;
152         return OpenILS::Event->new('INVALID_USER_XACT_ID');
153     }
154
155     # A user is allowed to make credit card payments on his/her own behalf
156     # All other scenarious require permission
157     unless($type eq 'credit_card_payment' and $user_id == $e->requestor->id) {
158         return $e->die_event unless $e->allowed('CREATE_PAYMENT', $patron->home_ou);
159     }
160
161     # first collect the transactions and make sure the transaction
162     # user matches the requested user
163     my %xacts;
164     for my $pay (@{$payments->{payments}}) {
165         my $xact_id = $pay->[0];
166         my $xact = $e->retrieve_money_billable_transaction_summary($xact_id)
167             or return $e->die_event;
168         
169         if($xact->usr != $user_id) {
170             $e->rollback;
171             return OpenILS::Event->new('BAD_PARAMS', note => q/user does not match transaction/);
172         }
173
174         $xacts{$xact_id} = $xact;
175     }
176
177     my @payment_objs;
178
179     for my $pay (@{$payments->{payments}}) {
180         my $transid = $pay->[0];
181         my $amount = $pay->[1];
182         $amount =~ s/\$//og; # just to be safe
183         my $trans = $xacts{$transid};
184
185         $total_paid += $amount;
186
187         $orgs{$U->xact_org($transid, $e)} = 1;
188
189         # A negative payment is a refund.  
190         if( $amount < 0 ) {
191
192             # Negative credit card payments are not allowed
193             if($type eq 'credit_card_payment') {
194                 $e->rollback;
195                 return OpenILS::Event->new(
196                     'BAD_PARAMS', 
197                     note => q/Negative credit card payments not allowed/
198                 );
199             }
200
201             # If the refund causes the transaction balance to exceed 0 dollars, 
202             # we are in effect loaning the patron money.  This is not allowed.
203             if( ($trans->balance_owed - $amount) > 0 ) {
204                 $e->rollback;
205                 return OpenILS::Event->new('REFUND_EXCEEDS_BALANCE');
206             }
207
208             # Otherwise, make sure the refund does not exceed desk payments
209             # This is also not allowed
210             my $desk_total = 0;
211             my $desk_payments = $e->search_money_desk_payment({xact => $transid, voided => 'f'});
212             $desk_total += $_->amount for @$desk_payments;
213
214             if( (-$amount) > $desk_total ) {
215                 $e->rollback;
216                 return OpenILS::Event->new(
217                     'REFUND_EXCEEDS_DESK_PAYMENTS', 
218                     payload => { allowed_refund => $desk_total, submitted_refund => -$amount } );
219             }
220         }
221
222         my $payobj = "Fieldmapper::money::$type";
223         $payobj = $payobj->new;
224
225         $payobj->amount($amount);
226         $payobj->amount_collected($amount);
227         $payobj->xact($transid);
228         $payobj->note($note);
229         if ((not $payobj->note) and ($type eq 'credit_card_payment')) {
230             $payobj->note($cc_args->{note});
231         }
232
233         if ($payobj->has_field('accepting_usr')) { $payobj->accepting_usr($e->requestor->id); }
234         if ($payobj->has_field('cash_drawer')) { $payobj->cash_drawer($drawer); }
235         if ($payobj->has_field('cc_type')) { $payobj->cc_type($cc_args->{type}); }
236         if ($payobj->has_field('check_number')) { $payobj->check_number($check_number); }
237
238         # Store the last 4 digits of the CC number
239         if ($payobj->has_field('cc_number')) {
240             $payobj->cc_number(substr($cc_args->{number}, -4));
241         }
242         if ($payobj->has_field('expire_month')) { $payobj->expire_month($cc_args->{expire_month}); }
243         if ($payobj->has_field('expire_year')) { $payobj->expire_year($cc_args->{expire_year}); }
244         
245         # Note: It is important not to set approval_code
246         # on the fieldmapper object yet.
247
248         push(@payment_objs, $payobj);
249
250     } # all payment objects have been created and inserted. 
251
252     #### NO WRITES TO THE DB ABOVE THIS LINE -- THEY'LL ONLY BE DISCARDED  ###
253     $e->rollback;
254
255     # After we try to externally process a credit card (if desired), we'll
256     # open a new transaction.  We cannot leave one open while credit card
257     # processing might be happening, as it can easily time out the database
258     # transaction.
259
260     my $cc_payload;
261
262     if($type eq 'credit_card_payment') {
263         $approval_code = $cc_args->{approval_code};
264         # If an approval code was not given, we'll need
265         # to call to the payment processor ourselves.
266         if ($cc_args->{where_process} == 1) {
267             return OpenILS::Event->new('BAD_PARAMS', note => 'Need CC number')
268                 if not $cc_args->{number};
269             my $response =
270                 OpenILS::Application::Circ::CreditCard::process_payment({
271                     "desc" => $cc_args->{note},
272                     "amount" => $total_paid,
273                     "patron_id" => $user_id,
274                     "cc" => $cc_args->{number},
275                     "expiration" => sprintf(
276                         "%02d-%04d",
277                         $cc_args->{expire_month},
278                         $cc_args->{expire_year}
279                     ),
280                     "ou" => $this_ou,
281                     "first_name" => $cc_args->{billing_first},
282                     "last_name" => $cc_args->{billing_last},
283                     "address" => $cc_args->{billing_address},
284                     "city" => $cc_args->{billing_city},
285                     "state" => $cc_args->{billing_state},
286                     "zip" => $cc_args->{billing_zip},
287                     "cvv2" => $cc_args->{cvv2},
288                 });
289
290             if ($U->event_code($response)) { # non-success
291                 $logger->info(
292                     "Credit card payment for user $user_id failed: " .
293                     $response->{"textcode"} . " " .
294                     $response->{"payload"}->{"error_message"}
295                 );
296
297                 return $response;
298             } else {
299                 # We need to save this for later in case there's a failure on
300                 # the EG side to store the processor's result.
301                 $cc_payload = $response->{"payload"};
302
303                 $approval_code = $cc_payload->{"authorization"};
304                 $cc_type = $cc_payload->{"card_type"};
305                 $cc_processor = $cc_payload->{"processor"};
306                 $cc_order_number = $cc_payload->{"order_number"};
307                 $logger->info("Credit card payment for user $user_id succeeded");
308             }
309         } else {
310             return OpenILS::Event->new(
311                 'BAD_PARAMS', note => 'Need approval code'
312             ) if not $cc_args->{approval_code};
313         }
314     }
315
316     ### RE-OPEN TRANSACTION HERE ###
317     $e->xact_begin;
318     my @payment_ids;
319
320     # create payment records
321     my $create_money_method = "create_money_" . $type;
322     for my $payment (@payment_objs) {
323         # update the transaction if it's done
324         my $amount = $payment->amount;
325         my $transid = $payment->xact;
326         my $trans = $xacts{$transid};
327         # making payment with existing patron credit.
328         $credit -= $amount if $type eq 'credit_payment';
329         if( (my $cred = ($trans->balance_owed - $amount)) <= 0 ) {
330             # Any overpay on this transaction goes directly into patron
331             # credit
332             $cred = -$cred;
333             $credit += $cred;
334             my $circ = $e->retrieve_action_circulation($transid);
335
336             if(!$circ || $circ->stop_fines) {
337                 # If this is a circulation, we can't close the transaction
338                 # unless stop_fines is set.
339                 $trans = $e->retrieve_money_billable_transaction($transid);
340                 $trans->xact_finish("now");
341                 if (!$e->update_money_billable_transaction($trans)) {
342                     return _recording_failure(
343                         $e, "update_money_billable_transaction() failed",
344                         $payment, $cc_payload
345                     )
346                 }
347             }
348         }
349
350         $payment->approval_code($approval_code) if $approval_code;
351         $payment->cc_order_number($cc_order_number) if $cc_order_number;
352         $payment->cc_type($cc_type) if $cc_type;
353         $payment->cc_processor($cc_processor) if $cc_processor;
354         $payment->cc_first_name($cc_args->{'billing_first'}) if $cc_args->{'billing_first'};
355         $payment->cc_last_name($cc_args->{'billing_last'}) if $cc_args->{'billing_last'};
356         if (!$e->$create_money_method($payment)) {
357             return _recording_failure(
358                 $e, "$create_money_method failed", $payment, $cc_payload
359             );
360         }
361
362         push(@payment_ids, $payment->id);
363     }
364
365     my $evt = _update_patron_credit($e, $patron, $credit);
366     if ($evt) {
367         return _recording_failure(
368             $e, "_update_patron_credit() failed", undef, $cc_payload
369         );
370     }
371
372     for my $org_id (keys %orgs) {
373         # calculate penalties for each of the affected orgs
374         $evt = OpenILS::Utils::Penalty->calculate_penalties(
375             $e, $user_id, $org_id
376         );
377         if ($evt) {
378             return _recording_failure(
379                 $e, "calculate_penalties() failed", undef, $cc_payload
380             );
381         }
382     }
383
384     # update the user to create a new last_xact_id
385     $e->update_actor_user($patron) or return $e->die_event;
386     $patron = $e->retrieve_actor_user($patron) or return $e->die_event;
387     $e->commit;
388
389     # update the cached user object if a user is making a payment toward 
390     # his/her own account
391     $U->simplereq('open-ils.auth', 'open-ils.auth.session.reset_timeout', $auth, 1)
392         if $user_id == $e->requestor->id;
393
394     return {last_xact_id => $patron->last_xact_id, payments => \@payment_ids};
395 }
396
397 sub _recording_failure {
398     my ($e, $msg, $payment, $payload) = @_;
399
400     if ($payload) { # If the payment processor already accepted a payment:
401         $logger->error($msg);
402         $logger->error("Payment processor payload: " . Dumper($payload));
403         # payment shouldn't contain CC number
404         $logger->error("Payment: " . Dumper($payment)) if $payment;
405
406         $e->rollback;
407
408         return new OpenILS::Event(
409             "CREDIT_PROCESSOR_SUCCESS_WO_RECORD",
410             "payload" => $payload
411         );
412     } else { # Otherwise, the problem is somewhat less severe:
413         $logger->warn($msg);
414         $logger->warn("Payment: " . Dumper($payment)) if $payment;
415         return $e->die_event;
416     }
417 }
418
419 sub _update_patron_credit {
420     my($e, $patron, $credit) = @_;
421     return undef if $credit == 0;
422     $patron->credit_forward_balance($patron->credit_forward_balance + $credit);
423     return OpenILS::Event->new('NEGATIVE_PATRON_BALANCE') if $patron->credit_forward_balance < 0;
424     $e->update_actor_user($patron) or return $e->die_event;
425     return undef;
426 }
427
428
429 __PACKAGE__->register_method(
430     method    => "retrieve_payments",
431     api_name    => "open-ils.circ.money.payment.retrieve.all_",
432     notes        => "Returns a list of payments attached to a given transaction"
433     );
434 sub retrieve_payments {
435     my( $self, $client, $login, $transid ) = @_;
436
437     my( $staff, $evt ) =  
438         $apputils->checksesperm($login, 'VIEW_TRANSACTION');
439     return $evt if $evt;
440
441     # XXX the logic here is wrong.. we need to check the owner of the transaction
442     # to make sure the requestor has access
443
444     # XXX grab the view, for each object in the view, grab the real object
445
446     return $apputils->simplereq(
447         'open-ils.cstore',
448         'open-ils.cstore.direct.money.payment.search.atomic', { xact => $transid } );
449 }
450
451
452 __PACKAGE__->register_method(
453     method    => "retrieve_payments2",
454     authoritative => 1,
455     api_name    => "open-ils.circ.money.payment.retrieve.all",
456     notes        => "Returns a list of payments attached to a given transaction"
457     );
458     
459 sub retrieve_payments2 {
460     my( $self, $client, $login, $transid ) = @_;
461
462     my $e = new_editor(authtoken=>$login);
463     return $e->event unless $e->checkauth;
464     return $e->event unless $e->allowed('VIEW_TRANSACTION');
465
466     my @payments;
467     my $pmnts = $e->search_money_payment({ xact => $transid });
468     for( @$pmnts ) {
469         my $type = $_->payment_type;
470         my $meth = "retrieve_money_$type";
471         my $p = $e->$meth($_->id) or return $e->event;
472         $p->payment_type($type);
473         $p->cash_drawer($e->retrieve_actor_workstation($p->cash_drawer))
474             if $p->has_field('cash_drawer');
475         push( @payments, $p );
476     }
477
478     return \@payments;
479 }
480
481 __PACKAGE__->register_method(
482     method    => "format_payment_receipt",
483     api_name  => "open-ils.circ.money.payment_receipt.print",
484     signature => {
485         desc   => 'Returns a printable receipt for the specified payments',
486         params => [
487             { desc => 'Authentication token',  type => 'string'},
488             { desc => 'Payment ID or array of payment IDs', type => 'number' },
489         ],
490         return => {
491             desc => q/An action_trigger.event object or error event./,
492             type => 'object',
493         }
494     }
495 );
496 __PACKAGE__->register_method(
497     method    => "format_payment_receipt",
498     api_name  => "open-ils.circ.money.payment_receipt.email",
499     signature => {
500         desc   => 'Emails a receipt for the specified payments to the user associated with the first payment',
501         params => [
502             { desc => 'Authentication token',  type => 'string'},
503             { desc => 'Payment ID or array of payment IDs', type => 'number' },
504         ],
505         return => {
506             desc => q/Undefined on success, otherwise an error event./,
507             type => 'object',
508         }
509     }
510 );
511
512 sub format_payment_receipt {
513     my($self, $conn, $auth, $mp_id) = @_;
514
515     my $mp_ids;
516     if (ref $mp_id ne 'ARRAY') {
517         $mp_ids = [ $mp_id ];
518     } else {
519         $mp_ids = $mp_id;
520     }
521
522     my $for_print = ($self->api_name =~ /print/);
523     my $for_email = ($self->api_name =~ /email/);
524
525     # manually use xact (i.e. authoritative) so we can kill the cstore
526     # connection before sending the action/trigger request.  This prevents our cstore
527     # backend from sitting idle while A/T (which uses its own transactions) runs.
528     my $e = new_editor(xact => 1, authtoken => $auth);
529     return $e->die_event unless $e->checkauth;
530
531     my $payments = [];
532     for my $id (@$mp_ids) {
533
534         my $payment = $e->retrieve_money_payment([
535             $id,
536             {   flesh => 2,
537                 flesh_fields => {
538                     mp => ['xact'],
539                     mbt => ['usr']
540                 }
541             }
542         ]) or return $e->die_event;
543
544         return $e->die_event unless 
545             $e->requestor->id == $payment->xact->usr->id or
546             $e->allowed('VIEW_TRANSACTION', $payment->xact->usr->home_ou); 
547
548         push @$payments, $payment;
549     }
550
551     $e->rollback;
552
553     if ($for_print) {
554
555         return $U->fire_object_event(undef, 'money.format.payment_receipt.print', $payments, $$payments[0]->xact->usr->home_ou);
556
557     } elsif ($for_email) {
558
559         for my $p (@$payments) {
560             $U->create_events_for_hook('money.format.payment_receipt.email', $p, $p->xact->usr->home_ou, undef, undef, 1);
561         }
562     }
563
564     return undef;
565 }
566
567 __PACKAGE__->register_method(
568     method    => "create_grocery_bill",
569     api_name    => "open-ils.circ.money.grocery.create",
570     notes        => <<"    NOTE");
571     Creates a new grocery transaction using the transaction object provided
572     PARAMS: (login_session, money.grocery (mg) object)
573     NOTE
574
575 sub create_grocery_bill {
576     my( $self, $client, $login, $transaction ) = @_;
577
578     my( $staff, $evt ) = $apputils->checkses($login);
579     return $evt if $evt;
580     $evt = $apputils->check_perms($staff->id, 
581         $transaction->billing_location, 'CREATE_TRANSACTION' );
582     return $evt if $evt;
583
584
585     $logger->activity("Creating grocery bill " . Dumper($transaction) );
586
587     $transaction->clear_id;
588     my $session = $apputils->start_db_session;
589     my $transid = $session->request(
590         'open-ils.storage.direct.money.grocery.create', $transaction)->gather(1);
591
592     throw OpenSRF::EX ("Error creating new money.grocery") unless defined $transid;
593
594     $logger->debug("Created new grocery transaction $transid");
595     
596     $apputils->commit_db_session($session);
597
598     my $e = new_editor(xact=>1);
599     $evt = _check_open_xact($e, $transid);
600     return $evt if $evt;
601     $e->commit;
602
603     return $transid;
604 }
605
606
607 __PACKAGE__->register_method(
608     method => 'fetch_reservation',
609     api_name => 'open-ils.circ.booking.reservation.retrieve'
610 );
611 sub fetch_reservation {
612     my( $self, $conn, $auth, $id ) = @_;
613     my $e = new_editor(authtoken=>$auth);
614     return $e->event unless $e->checkauth;
615     return $e->event unless $e->allowed('VIEW_TRANSACTION'); # eh.. basically the same permission
616     my $g = $e->retrieve_booking_reservation($id)
617         or return $e->event;
618     return $g;
619 }
620
621 __PACKAGE__->register_method(
622     method   => 'fetch_grocery',
623     api_name => 'open-ils.circ.money.grocery.retrieve'
624 );
625 sub fetch_grocery {
626     my( $self, $conn, $auth, $id ) = @_;
627     my $e = new_editor(authtoken=>$auth);
628     return $e->event unless $e->checkauth;
629     return $e->event unless $e->allowed('VIEW_TRANSACTION'); # eh.. basically the same permission
630     my $g = $e->retrieve_money_grocery($id)
631         or return $e->event;
632     return $g;
633 }
634
635
636 __PACKAGE__->register_method(
637     method        => "billing_items",
638     api_name      => "open-ils.circ.money.billing.retrieve.all",
639     authoritative => 1,
640     signature     => {
641         desc   => 'Returns a list of billing items for the given transaction ID.  ' .
642                   'If the operator is not the owner of the transaction, the VIEW_TRANSACTION permission is required.',
643         params => [
644             { desc => 'Authentication token', type => 'string'},
645             { desc => 'Transaction ID',       type => 'number'}
646         ],
647         return => {
648             desc => 'Transaction object, event on error'
649         },
650     }
651 );
652
653 sub billing_items {
654     my( $self, $client, $login, $transid ) = @_;
655
656     my( $trans, $evt ) = $U->fetch_billable_xact($transid);
657     return $evt if $evt;
658
659     my $staff;
660     ($staff, $evt ) = $apputils->checkses($login);
661     return $evt if $evt;
662
663     if($staff->id ne $trans->usr) {
664         $evt = $U->check_perms($staff->id, $staff->home_ou, 'VIEW_TRANSACTION');
665         return $evt if $evt;
666     }
667     
668     return $apputils->simplereq( 'open-ils.cstore',
669         'open-ils.cstore.direct.money.billing.search.atomic', { xact => $transid } )
670 }
671
672
673 __PACKAGE__->register_method(
674     method   => "billing_items_create",
675     api_name => "open-ils.circ.money.billing.create",
676     notes    => <<"    NOTE");
677     Creates a new billing line item
678     PARAMS( login, bill_object (mb) )
679     NOTE
680
681 sub billing_items_create {
682     my( $self, $client, $login, $billing ) = @_;
683
684     my $e = new_editor(authtoken => $login, xact => 1);
685     return $e->die_event unless $e->checkauth;
686     return $e->die_event unless $e->allowed('CREATE_BILL');
687
688     my $xact = $e->retrieve_money_billable_transaction($billing->xact)
689         or return $e->die_event;
690
691     # if the transaction was closed, re-open it
692     if($xact->xact_finish) {
693         $xact->clear_xact_finish;
694         $e->update_money_billable_transaction($xact)
695             or return $e->die_event;
696     }
697
698     my $amt = $billing->amount;
699     $amt =~ s/\$//og;
700     $billing->amount($amt);
701
702     $e->create_money_billing($billing) or return $e->die_event;
703     my $evt = OpenILS::Utils::Penalty->calculate_penalties($e, $xact->usr, $U->xact_org($xact->id));
704     return $evt if $evt;
705     $e->commit;
706
707     return $billing->id;
708 }
709
710
711 __PACKAGE__->register_method(
712     method        =>    'void_bill',
713     api_name        => 'open-ils.circ.money.billing.void',
714     signature    => q/
715         Voids a bill
716         @param authtoken Login session key
717         @param billid Id for the bill to void.  This parameter may be repeated to reference other bills.
718         @return 1 on success, Event on error
719     /
720 );
721 sub void_bill {
722     my( $s, $c, $authtoken, @billids ) = @_;
723
724     my $e = new_editor( authtoken => $authtoken, xact => 1 );
725     return $e->die_event unless $e->checkauth;
726     return $e->die_event unless $e->allowed('VOID_BILLING');
727
728     my %users;
729     for my $billid (@billids) {
730
731         my $bill = $e->retrieve_money_billing($billid)
732             or return $e->die_event;
733
734         my $xact = $e->retrieve_money_billable_transaction($bill->xact)
735             or return $e->die_event;
736
737         if($U->is_true($bill->voided)) {
738             $e->rollback;
739             return OpenILS::Event->new('BILL_ALREADY_VOIDED', payload => $bill);
740         }
741
742         my $org = $U->xact_org($bill->xact, $e);
743         $users{$xact->usr} = {} unless $users{$xact->usr};
744         $users{$xact->usr}->{$org} = 1;
745
746         $bill->voided('t');
747         $bill->voider($e->requestor->id);
748         $bill->void_time('now');
749     
750         $e->update_money_billing($bill) or return $e->die_event;
751         my $evt = _check_open_xact($e, $bill->xact, $xact);
752         return $evt if $evt;
753     }
754
755     # calculate penalties for all user/org combinations
756     for my $user_id (keys %users) {
757         for my $org_id (keys %{$users{$user_id}}) {
758             OpenILS::Utils::Penalty->calculate_penalties($e, $user_id, $org_id);
759         }
760     }
761     $e->commit;
762     return 1;
763 }
764
765
766 __PACKAGE__->register_method(
767     method        =>    'edit_bill_note',
768     api_name        => 'open-ils.circ.money.billing.note.edit',
769     signature    => q/
770         Edits the note for a bill
771         @param authtoken Login session key
772         @param note The replacement note for the bills we're editing
773         @param billid Id for the bill to edit the note of.  This parameter may be repeated to reference other bills.
774         @return 1 on success, Event on error
775     /
776 );
777 sub edit_bill_note {
778     my( $s, $c, $authtoken, $note, @billids ) = @_;
779
780     my $e = new_editor( authtoken => $authtoken, xact => 1 );
781     return $e->die_event unless $e->checkauth;
782     return $e->die_event unless $e->allowed('UPDATE_BILL_NOTE');
783
784     for my $billid (@billids) {
785
786         my $bill = $e->retrieve_money_billing($billid)
787             or return $e->die_event;
788
789         $bill->note($note);
790         # FIXME: Does this get audited?  Need some way so that the original creator of the bill does not get credit/blame for the new note.
791     
792         $e->update_money_billing($bill) or return $e->die_event;
793     }
794     $e->commit;
795     return 1;
796 }
797
798
799 __PACKAGE__->register_method(
800     method        =>    'edit_payment_note',
801     api_name        => 'open-ils.circ.money.payment.note.edit',
802     signature    => q/
803         Edits the note for a payment
804         @param authtoken Login session key
805         @param note The replacement note for the payments we're editing
806         @param paymentid Id for the payment to edit the note of.  This parameter may be repeated to reference other payments.
807         @return 1 on success, Event on error
808     /
809 );
810 sub edit_payment_note {
811     my( $s, $c, $authtoken, $note, @paymentids ) = @_;
812
813     my $e = new_editor( authtoken => $authtoken, xact => 1 );
814     return $e->die_event unless $e->checkauth;
815     return $e->die_event unless $e->allowed('UPDATE_PAYMENT_NOTE');
816
817     for my $paymentid (@paymentids) {
818
819         my $payment = $e->retrieve_money_payment($paymentid)
820             or return $e->die_event;
821
822         $payment->note($note);
823         # FIXME: Does this get audited?  Need some way so that the original taker of the payment does not get credit/blame for the new note.
824     
825         $e->update_money_payment($payment) or return $e->die_event;
826     }
827
828     $e->commit;
829     return 1;
830 }
831
832 sub _check_open_xact {
833     my( $editor, $xactid, $xact ) = @_;
834
835     # Grab the transaction
836     $xact ||= $editor->retrieve_money_billable_transaction($xactid);
837     return $editor->event unless $xact;
838     $xactid ||= $xact->id;
839
840     # grab the summary and see how much is owed on this transaction
841     my ($summary) = $U->fetch_mbts($xactid, $editor);
842
843     # grab the circulation if it is a circ;
844     my $circ = $editor->retrieve_action_circulation($xactid);
845
846     # If nothing is owed on the transaction but it is still open
847     # and this transaction is not an open circulation, close it
848     if( 
849         ( $summary->balance_owed == 0 and ! $xact->xact_finish ) and
850         ( !$circ or $circ->stop_fines )) {
851
852         $logger->info("closing transaction ".$xact->id. ' becauase balance_owed == 0');
853         $xact->xact_finish('now');
854         $editor->update_money_billable_transaction($xact)
855             or return $editor->event;
856         return undef;
857     }
858
859     # If money is owed or a refund is due on the xact and xact_finish
860     # is set, clear it (to reopen the xact) and update
861     if( $summary->balance_owed != 0 and $xact->xact_finish ) {
862         $logger->info("re-opening transaction ".$xact->id. ' becauase balance_owed != 0');
863         $xact->clear_xact_finish;
864         $editor->update_money_billable_transaction($xact)
865             or return $editor->event;
866         return undef;
867     }
868     return undef;
869 }
870
871
872 __PACKAGE__->register_method (
873     method => 'fetch_mbts',
874     authoritative => 1,
875     api_name => 'open-ils.circ.money.billable_xact_summary.retrieve'
876 );
877 sub fetch_mbts {
878     my( $self, $conn, $auth, $id) = @_;
879
880     my $e = new_editor(xact => 1, authtoken=>$auth);
881     return $e->event unless $e->checkauth;
882     my ($mbts) = $U->fetch_mbts($id, $e);
883
884     my $user = $e->retrieve_actor_user($mbts->usr)
885         or return $e->die_event;
886
887     return $e->die_event unless $e->allowed('VIEW_TRANSACTION', $user->home_ou);
888     $e->rollback;
889     return $mbts
890 }
891
892
893 __PACKAGE__->register_method(
894     method => 'desk_payments',
895     api_name => 'open-ils.circ.money.org_unit.desk_payments'
896 );
897 sub desk_payments {
898     my( $self, $conn, $auth, $org, $start_date, $end_date ) = @_;
899     my $e = new_editor(authtoken=>$auth);
900     return $e->event unless $e->checkauth;
901     return $e->event unless $e->allowed('VIEW_TRANSACTION', $org);
902     my $data = $U->storagereq(
903         'open-ils.storage.money.org_unit.desk_payments.atomic',
904         $org, $start_date, $end_date );
905
906     $_->workstation( $_->workstation->name ) for(@$data);
907     return $data;
908 }
909
910
911 __PACKAGE__->register_method(
912     method => 'user_payments',
913     api_name => 'open-ils.circ.money.org_unit.user_payments'
914 );
915
916 sub user_payments {
917     my( $self, $conn, $auth, $org, $start_date, $end_date ) = @_;
918     my $e = new_editor(authtoken=>$auth);
919     return $e->event unless $e->checkauth;
920     return $e->event unless $e->allowed('VIEW_TRANSACTION', $org);
921     my $data = $U->storagereq(
922         'open-ils.storage.money.org_unit.user_payments.atomic',
923         $org, $start_date, $end_date );
924     for(@$data) {
925         $_->usr->card(
926             $e->retrieve_actor_card($_->usr->card)->barcode);
927         $_->usr->home_ou(
928             $e->retrieve_actor_org_unit($_->usr->home_ou)->shortname);
929     }
930     return $data;
931 }
932
933
934 __PACKAGE__->register_method(
935     method    => 'retrieve_credit_payable_balance',
936     api_name  => 'open-ils.circ.credit.payable_balance.retrieve',
937     authoritative => 1,
938     signature => {
939         desc   => q/Returns the total amount the patron can pay via credit card/,
940         params => [
941             { desc => 'Authentication token', type => 'string' },
942             { desc => 'User id', type => 'number' }
943         ],
944         return => { desc => 'The ID of the new provider' }
945     }
946 );
947
948 sub retrieve_credit_payable_balance {
949     my ( $self, $conn, $auth, $user_id ) = @_;
950     my $e = new_editor(authtoken => $auth);
951     return $e->event unless $e->checkauth;
952
953     my $user = $e->retrieve_actor_user($user_id) 
954         or return $e->event;
955
956     if($e->requestor->id != $user_id) {
957         return $e->event unless $e->allowed('VIEW_USER_TRANSACTIONS', $user->home_ou)
958     }
959
960     my $circ_orgs = $e->json_query({
961         "select" => {circ => ["circ_lib"]},
962         from     => "circ",
963         "where"  => {usr => $user_id, xact_finish => undef},
964         distinct => 1
965     });
966
967     my $groc_orgs = $e->json_query({
968         "select" => {mg => ["billing_location"]},
969         from     => "mg",
970         "where"  => {usr => $user_id, xact_finish => undef},
971         distinct => 1
972     });
973
974     my %hash;
975     for my $org ( @$circ_orgs, @$groc_orgs ) {
976         my $o = $org->{billing_location};
977         $o = $org->{circ_lib} unless $o;
978         next if $hash{$o};    # was $hash{$org}, but that doesn't make sense.  $org is a hashref and $o gets added in the next line.
979         $hash{$o} = $U->ou_ancestor_setting_value($o, 'credit.payments.allow', $e);
980     }
981
982     my @credit_orgs = map { $hash{$_} ? ($_) : () } keys %hash;
983     $logger->debug("credit: relevant orgs that allow credit payments => @credit_orgs");
984
985     my $xact_summaries =
986       OpenILS::Application::AppUtils->simplereq('open-ils.actor',
987         'open-ils.actor.user.transactions.have_charge', $auth, $user_id);
988
989     my $sum = 0.0;
990
991     for my $xact (@$xact_summaries) {
992
993         # make two lists and grab them in batch XXX
994         if ( $xact->xact_type eq 'circulation' ) {
995             my $circ = $e->retrieve_action_circulation($xact->id) or return $e->event;
996             next unless grep { $_ == $circ->circ_lib } @credit_orgs;
997
998         } elsif ($xact->xact_type eq 'grocery') {
999             my $bill = $e->retrieve_money_grocery($xact->id) or return $e->event;
1000             next unless grep { $_ == $bill->billing_location } @credit_orgs;
1001         } elsif ($xact->xact_type eq 'reservation') {
1002             my $bill = $e->retrieve_booking_reservation($xact->id) or return $e->event;
1003             next unless grep { $_ == $bill->pickup_lib } @credit_orgs;
1004         }
1005         $sum += $xact->balance_owed();
1006     }
1007
1008     return $sum;
1009 }
1010
1011
1012 1;