3a59bf93aa4a1473350c5578ad30b722c4e29b6c
[working/Evergreen.git] / Open-ILS / src / perlmods / lib / OpenILS / Application / Circ.pm
1 package OpenILS::Application::Circ;
2 use OpenILS::Application;
3 use base qw/OpenILS::Application/;
4 use strict; use warnings;
5
6 use OpenILS::Application::Circ::Circulate;
7 use OpenILS::Application::Circ::Survey;
8 use OpenILS::Application::Circ::StatCat;
9 use OpenILS::Application::Circ::Holds;
10 use OpenILS::Application::Circ::HoldNotify;
11 use OpenILS::Application::Circ::CircNotify;
12 use OpenILS::Application::Circ::CreditCard;
13 use OpenILS::Application::Circ::Money;
14 use OpenILS::Application::Circ::NonCat;
15 use OpenILS::Application::Circ::CopyLocations;
16 use OpenILS::Application::Circ::CircCommon;
17
18 use DateTime;
19 use DateTime::Format::ISO8601;
20
21 use OpenILS::Application::AppUtils;
22
23 use OpenSRF::Utils qw/:datetime/;
24 use OpenSRF::AppSession;
25 use OpenILS::Utils::ModsParser;
26 use OpenILS::Event;
27 use OpenSRF::EX qw(:try);
28 use OpenSRF::Utils::Logger qw(:logger);
29 use OpenILS::Utils::Fieldmapper;
30 use OpenILS::Utils::CStoreEditor q/:funcs/;
31 use OpenILS::Const qw/:const/;
32 use OpenSRF::Utils::SettingsClient;
33 use OpenILS::Application::Cat::AssetCommon;
34
35 my $apputils = "OpenILS::Application::AppUtils";
36 my $U = $apputils;
37
38 my $holdcode    = "OpenILS::Application::Circ::Holds";
39
40 # ------------------------------------------------------------------------
41 # Top level Circ package;
42 # ------------------------------------------------------------------------
43
44 sub initialize {
45     my $self = shift;
46     OpenILS::Application::Circ::Circulate->initialize();
47 }
48
49
50 __PACKAGE__->register_method(
51     method => 'retrieve_circ',
52     authoritative   => 1,
53     api_name    => 'open-ils.circ.retrieve',
54     signature => q/
55         Retrieve a circ object by id
56         @param authtoken Login session key
57         @pararm circid The id of the circ object
58         @param all_circ Returns an action.all_circulation_slim object instead
59             of an action.circulation object to pick up aged circs.
60     /
61 );
62
63 sub retrieve_circ {
64     my( $s, $c, $a, $i, $all_circ ) = @_;
65     my $e = new_editor(authtoken => $a);
66     return $e->event unless $e->checkauth;
67     my $method = $all_circ ?
68         'retrieve_action_all_circulation_slim' :
69         'retrieve_action_circulation';
70     my $circ = $e->$method($i) or return $e->event;
71     if( $e->requestor->id ne ($circ->usr || '') ) {
72         return $e->event unless $e->allowed('VIEW_CIRCULATIONS');
73     }
74     return $circ;
75 }
76
77
78 __PACKAGE__->register_method(
79     method => 'fetch_circ_mods',
80     api_name => 'open-ils.circ.circ_modifier.retrieve.all');
81 sub fetch_circ_mods {
82     my($self, $conn, $args) = @_;
83     my $mods = new_editor()->retrieve_all_config_circ_modifier;
84     return [ map {$_->code} @$mods ] unless $$args{full};
85     return $mods;
86 }
87
88 __PACKAGE__->register_method(
89     method => 'ranged_billing_types',
90     api_name => 'open-ils.circ.billing_type.ranged.retrieve.all');
91
92 sub ranged_billing_types {
93     my($self, $conn, $auth, $org_id, $depth) = @_;
94     my $e = new_editor(authtoken => $auth);
95     return $e->event unless $e->checkauth;
96     return $e->event unless $e->allowed('VIEW_BILLING_TYPE', $org_id);
97     return $e->search_config_billing_type(
98         {owner => $U->get_org_full_path($org_id, $depth)});
99 }
100
101
102
103 # ------------------------------------------------------------------------
104 # Returns an array of {circ, record} hashes checked out by the user.
105 # ------------------------------------------------------------------------
106 __PACKAGE__->register_method(
107     method  => "checkouts_by_user",
108     api_name    => "open-ils.circ.actor.user.checked_out",
109     stream => 1,
110     NOTES        => <<"    NOTES");
111     Returns a list of open circulations as a pile of objects.  Each object
112     contains the relevant copy, circ, and record
113     NOTES
114
115 sub checkouts_by_user {
116     my($self, $client, $auth, $user_id) = @_;
117
118     my $e = new_editor(authtoken=>$auth);
119     return $e->event unless $e->checkauth;
120
121     my $circ_ids = $e->search_action_circulation(
122         {   usr => $user_id,
123             checkin_time => undef,
124             '-or' => [
125                 {stop_fines => undef},
126                 {stop_fines => ['MAXFINES','LONGOVERDUE']}
127             ]
128         },
129         {idlist => 1}
130     );
131
132     for my $id (@$circ_ids) {
133         my $circ = $e->retrieve_action_circulation([
134             $id,
135             {   flesh => 3,
136                 flesh_fields => {
137                     circ => ['target_copy'],
138                     acp => ['call_number'],
139                     acn => ['record']
140                 }
141             }
142         ]);
143
144         # un-flesh for consistency
145         my $c = $circ->target_copy;
146         $circ->target_copy($c->id);
147
148         my $cn = $c->call_number;
149         $c->call_number($cn->id);
150
151         my $t = $cn->record;
152         $cn->record($t->id);
153
154         $client->respond(
155             {   circ => $circ,
156                 copy => $c,
157                 record => $U->record_to_mvr($t)
158             }
159         );
160     }
161
162     return undef;
163 }
164
165
166
167 __PACKAGE__->register_method(
168     method  => "checkouts_by_user_slim",
169     api_name    => "open-ils.circ.actor.user.checked_out.slim",
170     NOTES        => <<"    NOTES");
171     Returns a list of open circulation objects
172     NOTES
173
174 # DEPRECAT ME?? XXX
175 sub checkouts_by_user_slim {
176     my( $self, $client, $user_session, $user_id ) = @_;
177
178     my( $requestor, $target, $copy, $record, $evt );
179
180     ( $requestor, $target, $evt ) = 
181         $apputils->checkses_requestor( $user_session, $user_id, 'VIEW_CIRCULATIONS');
182     return $evt if $evt;
183
184     $logger->debug( 'User ' . $requestor->id . 
185         " retrieving checked out items for user " . $target->id );
186
187     # XXX Make the call correct..
188     return $apputils->simplereq(
189         'open-ils.cstore',
190         "open-ils.cstore.direct.action.open_circulation.search.atomic", 
191         { usr => $target->id, checkin_time => undef } );
192 #       { usr => $target->id } );
193 }
194
195
196 __PACKAGE__->register_method(
197     method  => "checkouts_by_user_opac",
198     api_name    => "open-ils.circ.actor.user.checked_out.opac",);
199
200 # XXX Deprecate Me
201 sub checkouts_by_user_opac {
202     my( $self, $client, $auth, $user_id ) = @_;
203
204     my $e = new_editor( authtoken => $auth );
205     return $e->event unless $e->checkauth;
206     $user_id ||= $e->requestor->id;
207     return $e->event unless 
208         my $patron = $e->retrieve_actor_user($user_id);
209
210     my $data;
211     my $search = {usr => $user_id, stop_fines => undef};
212
213     if( $user_id ne $e->requestor->id ) {
214         $data = $e->search_action_circulation(
215             $search, {checkperm=>1, permorg=>$patron->home_ou})
216             or return $e->event;
217
218     } else {
219         $data = $e->search_action_circulation($search);
220     }
221
222     return $data;
223 }
224
225
226 __PACKAGE__->register_method(
227     method  => "title_from_transaction",
228     api_name    => "open-ils.circ.circ_transaction.find_title",
229     NOTES        => <<"    NOTES");
230     Returns a mods object for the title that is linked to from the 
231     copy from the hold that created the given transaction
232     NOTES
233
234 sub title_from_transaction {
235     my( $self, $client, $login_session, $transactionid ) = @_;
236
237     my( $user, $circ, $title, $evt );
238
239     ( $user, $evt ) = $apputils->checkses( $login_session );
240     return $evt if $evt;
241
242     ( $circ, $evt ) = $apputils->fetch_circulation($transactionid);
243     return $evt if $evt;
244     
245     ($title, $evt) = $apputils->fetch_record_by_copy($circ->target_copy);
246     return $evt if $evt;
247
248     return $apputils->record_to_mvr($title);
249 }
250
251 __PACKAGE__->register_method(
252     method  => "staff_age_to_lost",
253     api_name    => "open-ils.circ.circulation.age_to_lost",
254     stream => 1,
255     signature   => q/
256         This fires a circ.staff_age_to_lost Action-Trigger event against all
257         overdue circulations in scope of the specified context library and
258         user profile, which effectively marks the associated items as Lost.
259         This is likely to be done at the end of a semester in an academic
260         library, etc.
261         @param auth
262         @param args : circ_lib, user_profile
263     /
264 );
265
266 sub staff_age_to_lost {
267     my( $self, $conn, $auth, $args ) = @_;
268     my $e = new_editor(authtoken=>$auth);
269     return $e->event unless $e->checkauth;
270     return $e->event unless $e->allowed('SET_CIRC_LOST', $args->{'circ_lib'});
271
272     my $orgs = $U->get_org_descendants($args->{'circ_lib'});
273     my $profiles = $U->fetch_permission_group_descendants($args->{'user_profile'});
274
275     my $ses = OpenSRF::AppSession->create('open-ils.trigger');
276
277     my $method = 'open-ils.trigger.passive.event.autocreate.batch';
278     my $hook = 'circ.staff_age_to_lost';
279     my $context_org = 'circ_lib';
280     my $opt_granularity = undef;
281     my $filter = { 
282         "checkin_time" => undef,
283         "due_date" => { "<" => "now" }, 
284         "-or" => [ 
285             { "stop_fines"  => ["MAXFINES", "LONGOVERDUE"] }, # FIXME: CLAIMSRETURNED also?
286             { "stop_fines"  => undef }
287         ],
288         "-and" => [
289             {"-exists" => {
290                 "select" => {"au" => ["id"]},
291                 "from"   => "au",
292                 "where"  => {
293                     "profile" => $profiles,
294                     "id" => { "=" => {"+circ" => "usr"} }
295                 }
296             }},
297             {"-exists" => {
298                 "select" => {"aou" => ["id"]},
299                 "from"   => "aou",
300                 "where"  => {
301                     "-and" => [
302                         {"id" => { "=" => {"+circ" => "circ_lib"} }},
303                         {"id" => $orgs}
304                     ]
305                 }
306             }}
307         ]
308     };
309     my $req_timeout = 10800;
310     my $chunk_size = 100;
311     my $progress = 1;
312
313     my $req = $ses->request($method, $hook, $context_org, $filter, $opt_granularity);
314     my @event_ids; my @chunked_ids;
315     while (my $resp = $req->recv(timeout => $req_timeout)) {
316         push(@event_ids, $resp->content);
317         push(@chunked_ids, $resp->content);
318         if (scalar(@chunked_ids) > $chunk_size) {
319             $conn->respond({'progress'=>$progress++}); # 'event_ids'=>@chunked_ids
320             @chunked_ids = ();
321         }
322     }
323     if (scalar(@chunked_ids) > 0) {
324         $conn->respond({'progress'=>$progress++}); # 'event_ids'=>@chunked_ids
325     }
326
327     if(@event_ids) {
328         $logger->info("staff_age_to_lost: created ".scalar(@event_ids)." events for circ.staff_age_to_lost");
329         $conn->respond_complete({'total_progress'=>$progress-1,'created'=>scalar(@event_ids)});
330     } elsif($req->complete) {
331         $logger->info("staff_age_to_lost: no events to create for circ.staff_age_to_lost");
332         $conn->respond_complete({'total_progress'=>$progress-1,'created'=>0});
333     } else {
334         $logger->warn("staff_age_to_lost: timeout occurred during event creation for circ.staff_age_to_lost");
335         $conn->respond_complete({'total_progress'=>$progress-1,'error'=>'timeout'});
336     }
337
338     return undef;
339 }
340
341
342 __PACKAGE__->register_method(
343     method  => "new_set_circ_lost",
344     api_name    => "open-ils.circ.circulation.set_lost",
345     signature   => q/
346         Sets the copy and related open circulation to lost
347         @param auth
348         @param args : barcode
349     /
350 );
351
352
353 # ---------------------------------------------------------------------
354 # Sets a circulation to lost.  updates copy status to lost
355 # applies copy and/or prcoessing fees depending on org settings
356 # ---------------------------------------------------------------------
357 sub new_set_circ_lost {
358     my( $self, $conn, $auth, $args ) = @_;
359
360     my $e = new_editor(authtoken=>$auth, xact=>1);
361     return $e->die_event unless $e->checkauth;
362
363     my $copy = $e->search_asset_copy({barcode=>$$args{barcode}, deleted=>'f'})->[0]
364         or return $e->die_event;
365
366     my $evt = OpenILS::Application::Cat::AssetCommon->set_item_lost($e, $copy->id);
367     return $evt if $evt;
368
369     $e->commit;
370     return 1;
371 }
372
373
374 __PACKAGE__->register_method(
375     method  => "set_circ_claims_returned",
376     api_name    => "open-ils.circ.circulation.set_claims_returned",
377     signature => {
378         desc => q/Sets the circ for a given item as claims returned
379                 If a backdate is provided, overdue fines will be voided
380                 back to the backdate/,
381         params => [
382             {desc => 'Authentication token', type => 'string'},
383             {desc => 'Arguments, including "barcode" and optional "backdate"', type => 'object'}
384         ],
385         return => {desc => q/1 on success, failure event on error, and 
386             PATRON_EXCEEDS_CLAIMS_RETURN_COUNT if the patron exceeds the 
387             configured claims return maximum/}
388     }
389 );
390
391 __PACKAGE__->register_method(
392     method  => "set_circ_claims_returned",
393     api_name    => "open-ils.circ.circulation.set_claims_returned.override",
394     signature => {
395         desc => q/This adds support for overrideing the configured max 
396                 claims returned amount. 
397                 @see open-ils.circ.circulation.set_claims_returned./,
398     }
399 );
400
401 sub set_circ_claims_returned {
402     my( $self, $conn, $auth, $args, $oargs ) = @_;
403
404     my $e = new_editor(authtoken=>$auth, xact=>1);
405     return $e->die_event unless $e->checkauth;
406
407     $oargs = { all => 1 } unless defined $oargs;
408
409     my $barcode = $$args{barcode};
410     my $backdate = $$args{backdate};
411
412     my $copy = $e->search_asset_copy({barcode=>$barcode, deleted=>'f'})->[0] 
413         or return $e->die_event;
414
415     my $circ = $e->search_action_circulation(
416         {checkin_time => undef, target_copy => $copy->id})->[0]
417             or return $e->die_event;
418
419     $backdate = $circ->due_date if $$args{use_due_date};
420
421     $logger->info("marking circ for item $barcode as claims returned".
422         (($backdate) ? " with backdate $backdate" : ''));
423
424     my $patron = $e->retrieve_actor_user($circ->usr);
425     my $max_count = $U->ou_ancestor_setting_value(
426         $circ->circ_lib, 'circ.max_patron_claim_return_count', $e);
427
428     # If the patron has too instances of many claims returned, 
429     # require an override to continue.  A configured max of 
430     # 0 means all attempts require an override
431     if(defined $max_count and $patron->claims_returned_count >= $max_count) {
432
433         if($self->api_name =~ /override/ && ($oargs->{all} || grep { $_ eq 'PATRON_EXCEEDS_CLAIMS_RETURN_COUNT' } @{$oargs->{events}})) {
434
435             # see if we're allowed to override
436             return $e->die_event unless 
437                 $e->allowed('SET_CIRC_CLAIMS_RETURNED.override', $circ->circ_lib);
438
439         } else {
440
441             # exit early and return the max claims return event
442             $e->rollback;
443             return OpenILS::Event->new(
444                 'PATRON_EXCEEDS_CLAIMS_RETURN_COUNT', 
445                 payload => {
446                     patron_count => $patron->claims_returned_count,
447                     max_count => $max_count
448                 }
449             );
450         }
451     }
452
453     $e->allowed('SET_CIRC_CLAIMS_RETURNED', $circ->circ_lib) 
454         or return $e->die_event;
455
456     $circ->stop_fines(OILS_STOP_FINES_CLAIMSRETURNED);
457     $circ->stop_fines_time('now') unless $circ->stop_fines_time;
458
459     if( $backdate ) {
460         $backdate = cleanse_ISO8601($backdate);
461
462         my $original_date = DateTime::Format::ISO8601->new->parse_datetime(cleanse_ISO8601($circ->due_date));
463         my $new_date = DateTime::Format::ISO8601->new->parse_datetime($backdate);
464         $backdate = $new_date->ymd . 'T' . $original_date->strftime('%T%z');
465
466         # clean it up once again; need a : in the timezone offset. E.g. -06:00 not -0600
467         $backdate = cleanse_ISO8601($backdate);
468
469         # make it look like the circ stopped at the cliams returned time
470         $circ->stop_fines_time($backdate);
471         my $evt = OpenILS::Application::Circ::CircCommon->void_or_zero_overdues($e, $circ, {backdate => $backdate, note => 'System: OVERDUE REVERSED FOR CLAIMS-RETURNED', force_zero => 1});
472         return $evt if $evt;
473     }
474
475     $e->update_action_circulation($circ) or return $e->die_event;
476
477     # see if there is a configured post-claims-return copy status
478     if(my $stat = $U->ou_ancestor_setting_value($circ->circ_lib, 'circ.claim_return.copy_status')) {
479         $copy->status($stat);
480         $copy->edit_date('now');
481         $copy->editor($e->requestor->id);
482         $e->update_asset_copy($copy) or return $e->die_event;
483     }
484
485     # Check if the copy circ lib wants lost fees voided on claims
486     # returned.
487     if ($U->is_true($U->ou_ancestor_setting_value($copy->circ_lib, 'circ.void_lost_on_claimsreturned', $e))) {
488         my $result = OpenILS::Application::Circ::CircCommon->void_lost(
489             $e,
490             $circ,
491             3
492         );
493         if ($result) {
494             $e->rollback;
495             return $result;
496         }
497     }
498
499     # Check if the copy circ lib wants lost processing fees voided on
500     # claims returned.
501     if ($U->is_true($U->ou_ancestor_setting_value($copy->circ_lib, 'circ.void_lost_proc_fee_on_claimsreturned', $e))) {
502         my $result = OpenILS::Application::Circ::CircCommon->void_lost(
503             $e,
504             $circ,
505             4
506         );
507         if ($result) {
508             $e->rollback;
509             return $result;
510         }
511     }
512
513     # Check if the copy circ lib wants longoverdue fees voided on claims
514     # returned.
515     if ($U->is_true($U->ou_ancestor_setting_value($copy->circ_lib, 'circ.void_longoverdue_on_claimsreturned', $e))) {
516         my $result = OpenILS::Application::Circ::CircCommon->void_lost(
517             $e,
518             $circ,
519             10
520         );
521         if ($result) {
522             $e->rollback;
523             return $result;
524         }
525     }
526
527     # Check if the copy circ lib wants longoverdue processing fees voided on
528     # claims returned.
529     if ($U->is_true($U->ou_ancestor_setting_value($copy->circ_lib, 'circ.void_longoverdue_proc_fee_on_claimsreturned', $e))) {
530         my $result = OpenILS::Application::Circ::CircCommon->void_lost(
531             $e,
532             $circ,
533             11
534         );
535         if ($result) {
536             $e->rollback;
537             return $result;
538         }
539     }
540
541     # Now that all data has been munged, do a no-op update of 
542     # the patron to force a change of the last_xact_id value.
543     $e->update_actor_user($e->retrieve_actor_user($circ->usr))
544         or return $e->die_event;
545
546     $e->commit;
547     return 1;
548 }
549
550
551 __PACKAGE__->register_method(
552     method  => "post_checkin_backdate_circ",
553     api_name    => "open-ils.circ.post_checkin_backdate",
554     signature => {
555         desc => q/Back-date an already checked in circulation/,
556         params => [
557             {desc => 'Authentication token', type => 'string'},
558             {desc => 'Circ ID', type => 'number'},
559             {desc => 'ISO8601 backdate', type => 'string'},
560         ],
561         return => {desc => q/1 on success, failure event on error/}
562     }
563 );
564
565 __PACKAGE__->register_method(
566     method  => "post_checkin_backdate_circ",
567     api_name    => "open-ils.circ.post_checkin_backdate.batch",
568     stream => 1,
569     signature => {
570         desc => q/@see open-ils.circ.post_checkin_backdate.  Batch mode/,
571         params => [
572             {desc => 'Authentication token', type => 'string'},
573             {desc => 'List of Circ ID', type => 'array'},
574             {desc => 'ISO8601 backdate', type => 'string'},
575         ],
576         return => {desc => q/Set of: 1 on success, failure event on error/}
577     }
578 );
579
580
581 sub post_checkin_backdate_circ {
582     my( $self, $conn, $auth, $circ_id, $backdate ) = @_;
583     my $e = new_editor(authtoken=>$auth);
584     return $e->die_event unless $e->checkauth;
585     if($self->api_name =~ /batch/) {
586         foreach my $c (@$circ_id) {
587             $conn->respond(post_checkin_backdate_circ_impl($e, $c, $backdate));
588         }
589     } else {
590         $conn->respond_complete(post_checkin_backdate_circ_impl($e, $circ_id, $backdate));
591     }
592
593     $e->disconnect;
594     return undef;
595 }
596
597
598 sub post_checkin_backdate_circ_impl {
599     my($e, $circ_id, $backdate) = @_;
600
601     $e->xact_begin;
602
603     my $circ = $e->retrieve_action_circulation($circ_id)
604         or return $e->die_event;
605
606     # anyone with checkin perms can backdate (more restrictive?)
607     return $e->die_event unless $e->allowed('COPY_CHECKIN', $circ->circ_lib);
608
609     # don't allow back-dating an open circulation
610     return OpenILS::Event->new('BAD_PARAMS') unless 
611         $backdate and $circ->checkin_time;
612
613     # update the checkin and stop_fines times to reflect the new backdate
614     $circ->stop_fines_time(cleanse_ISO8601($backdate));
615     $circ->checkin_time(cleanse_ISO8601($backdate));
616     $e->update_action_circulation($circ) or return $e->die_event;
617
618     # now void the overdues "erased" by the back-dating
619     my $evt = OpenILS::Application::Circ::CircCommon->void_or_zero_overdues($e, $circ, {backdate => $backdate});
620     return $evt if $evt;
621
622     # If the circ was closed before and the balance owned !=0, re-open the transaction
623     $evt = OpenILS::Application::Circ::CircCommon->reopen_xact($e, $circ->id);
624     return $evt if $evt;
625
626     $e->xact_commit;
627     return 1;
628 }
629
630
631
632 __PACKAGE__->register_method (
633     method      => 'set_circ_due_date',
634     api_name        => 'open-ils.circ.circulation.due_date.update',
635     signature   => q/
636         Updates the due_date on the given circ
637         @param authtoken
638         @param circid The id of the circ to update
639         @param date The timestamp of the new due date
640     /
641 );
642
643 sub set_circ_due_date {
644     my( $self, $conn, $auth, $circ_id, $date ) = @_;
645
646     my $e = new_editor(xact=>1, authtoken=>$auth);
647     return $e->die_event unless $e->checkauth;
648     my $circ = $e->retrieve_action_circulation($circ_id)
649         or return $e->die_event;
650
651     return $e->die_event unless $e->allowed('CIRC_OVERRIDE_DUE_DATE', $circ->circ_lib);
652     $date = cleanse_ISO8601($date);
653
654     if (!(interval_to_seconds($circ->duration) % 86400)) { # duration is divisible by days
655         my $original_date = DateTime::Format::ISO8601->new->parse_datetime(cleanse_ISO8601($circ->due_date));
656         my $new_date = DateTime::Format::ISO8601->new->parse_datetime($date);
657         $date = cleanse_ISO8601( $new_date->ymd . 'T' . $original_date->strftime('%T%z') );
658     }
659
660     $circ->due_date($date);
661     $e->update_action_circulation($circ) or return $e->die_event;
662     $e->commit;
663
664     return $circ;
665 }
666
667
668 __PACKAGE__->register_method(
669     method      => "create_in_house_use",
670     api_name        => 'open-ils.circ.in_house_use.create',
671     signature   =>  q/
672         Creates an in-house use action.
673         @param $authtoken The login session key
674         @param params A hash of params including
675             'location' The org unit id where the in-house use occurs
676             'copyid' The copy in question
677             'count' The number of in-house uses to apply to this copy
678         @return An array of id's representing the id's of the newly created
679         in-house use objects or an event on an error
680     /);
681
682 __PACKAGE__->register_method(
683     method      => "create_in_house_use",
684     api_name        => 'open-ils.circ.non_cat_in_house_use.create',
685 );
686
687
688 sub create_in_house_use {
689     my( $self, $client, $auth, $params ) = @_;
690
691     my( $evt, $copy );
692     my $org         = $params->{location};
693     my $copyid      = $params->{copyid};
694     my $count       = $params->{count} || 1;
695     my $nc_type     = $params->{non_cat_type};
696     my $use_time    = $params->{use_time} || 'now';
697
698     my $e = new_editor(xact=>1,authtoken=>$auth);
699     return $e->event unless $e->checkauth;
700     return $e->event unless $e->allowed('CREATE_IN_HOUSE_USE');
701
702     my $non_cat = 1 if $self->api_name =~ /non_cat/;
703
704     unless( $non_cat ) {
705         if( $copyid ) {
706             $copy = $e->retrieve_asset_copy($copyid) or return $e->event;
707         } else {
708             $copy = $e->search_asset_copy({barcode=>$params->{barcode}, deleted => 'f'})->[0]
709                 or return $e->event;
710             $copyid = $copy->id;
711         }
712     }
713
714     if( $use_time ne 'now' ) {
715         $use_time = cleanse_ISO8601($use_time);
716         $logger->debug("in_house_use setting use time to $use_time");
717     }
718
719     my @ids;
720     for(1..$count) {
721
722         my $ihu;
723         my $method;
724         my $cmeth;
725
726         if($non_cat) {
727             $ihu = Fieldmapper::action::non_cat_in_house_use->new;
728             $ihu->item_type($nc_type);
729             $method = 'open-ils.storage.direct.action.non_cat_in_house_use.create';
730             $cmeth = "create_action_non_cat_in_house_use";
731
732         } else {
733             $ihu = Fieldmapper::action::in_house_use->new;
734             $ihu->item($copyid);
735             $method = 'open-ils.storage.direct.action.in_house_use.create';
736             $cmeth = "create_action_in_house_use";
737         }
738
739         $ihu->staff($e->requestor->id);
740         $ihu->org_unit($org);
741         $ihu->use_time($use_time);
742
743         $ihu = $e->$cmeth($ihu) or return $e->event;
744         push( @ids, $ihu->id );
745     }
746
747     $e->commit;
748     return \@ids;
749 }
750
751
752
753
754
755 __PACKAGE__->register_method(
756     method  => "view_circs",
757     api_name    => "open-ils.circ.copy_checkout_history.retrieve",
758     notes       => q/
759         Retrieves the last X circs for a given copy
760         @param authtoken The login session key
761         @param copyid The copy to check
762         @param count How far to go back in the item history
763         @return An array of circ ids
764     /);
765
766 # ----------------------------------------------------------------------
767 # Returns $count most recent circs.  If count exceeds the configured 
768 # max, use the configured max instead
769 # ----------------------------------------------------------------------
770 sub view_circs {
771     my( $self, $client, $authtoken, $copyid, $count ) = @_; 
772
773     my $e = new_editor(authtoken => $authtoken);
774     return $e->event unless $e->checkauth;
775     
776     my $copy = $e->retrieve_asset_copy([
777         $copyid,
778         {   flesh => 1,
779             flesh_fields => {acp => ['call_number']}
780         }
781     ]) or return $e->event;
782
783     return $e->event unless $e->allowed(
784         'VIEW_COPY_CHECKOUT_HISTORY', 
785         ($copy->call_number == OILS_PRECAT_CALL_NUMBER) ? 
786             $copy->circ_lib : $copy->call_number->owning_lib);
787         
788     my $max_history = $U->ou_ancestor_setting_value(
789         $e->requestor->ws_ou, 'circ.item_checkout_history.max', $e);
790
791     if(defined $max_history) {
792         $count = $max_history unless defined $count and $count < $max_history;
793     } else {
794         $count = 4 unless defined $count;
795     }
796
797     return $e->search_action_all_circulation_slim([
798         {target_copy => $copyid}, 
799         {limit => $count, order_by => { aacs => "xact_start DESC" }} 
800     ]);
801 }
802
803
804 __PACKAGE__->register_method(
805     method  => "circ_count",
806     api_name    => "open-ils.circ.circulation.count",
807     notes       => q/
808         Returns the number of times the item has circulated
809         @param copyid The copy to check
810     /);
811
812 sub circ_count {
813     my( $self, $client, $copyid ) = @_; 
814
815     my $count = new_editor()->json_query({
816         select => {
817             circbyyr => [{
818                 column => 'count',
819                 transform => 'sum',
820                 aggregate => 1
821             }]
822         },
823         from => 'circbyyr',
824         where => {'+circbyyr' => {copy => $copyid}}
825     })->[0]->{count};
826
827     return {
828         total => {
829             when => 'total',
830             count => $count
831         }
832     };
833 }
834
835
836 __PACKAGE__->register_method(
837     method      => 'fetch_notes',
838     authoritative   => 1,
839     api_name        => 'open-ils.circ.copy_note.retrieve.all',
840     signature   => q/
841         Returns an array of copy note objects.  
842         @param args A named hash of parameters including:
843             authtoken   : Required if viewing non-public notes
844             itemid      : The id of the item whose notes we want to retrieve
845             pub         : True if all the caller wants are public notes
846         @return An array of note objects
847     /);
848
849 __PACKAGE__->register_method(
850     method      => 'fetch_notes',
851     api_name        => 'open-ils.circ.call_number_note.retrieve.all',
852     signature   => q/@see open-ils.circ.copy_note.retrieve.all/);
853
854 __PACKAGE__->register_method(
855     method      => 'fetch_notes',
856     api_name        => 'open-ils.circ.title_note.retrieve.all',
857     signature   => q/@see open-ils.circ.copy_note.retrieve.all/);
858
859
860 # NOTE: VIEW_COPY/VOLUME/TITLE_NOTES perms should always be global
861 sub fetch_notes {
862     my( $self, $connection, $args ) = @_;
863
864     my $id = $$args{itemid};
865     my $authtoken = $$args{authtoken};
866     my( $r, $evt);
867
868     if( $self->api_name =~ /copy/ ) {
869         if( $$args{pub} ) {
870             return $U->cstorereq(
871                 'open-ils.cstore.direct.asset.copy_note.search.atomic',
872                 { owning_copy => $id, pub => 't' } );
873         } else {
874             ( $r, $evt ) = $U->checksesperm($authtoken, 'VIEW_COPY_NOTES');
875             return $evt if $evt;
876             return $U->cstorereq(
877                 'open-ils.cstore.direct.asset.copy_note.search.atomic', {owning_copy => $id} );
878         }
879
880     } elsif( $self->api_name =~ /call_number/ ) {
881         if( $$args{pub} ) {
882             return $U->cstorereq(
883                 'open-ils.cstore.direct.asset.call_number_note.search.atomic',
884                 { call_number => $id, pub => 't' } );
885         } else {
886             ( $r, $evt ) = $U->checksesperm($authtoken, 'VIEW_VOLUME_NOTES');
887             return $evt if $evt;
888             return $U->cstorereq(
889                 'open-ils.cstore.direct.asset.call_number_note.search.atomic', { call_number => $id } );
890         }
891
892     } elsif( $self->api_name =~ /title/ ) {
893         if( $$args{pub} ) {
894             return $U->cstorereq(
895                 'open-ils.cstore.direct.bilbio.record_note.search.atomic',
896                 { record => $id, pub => 't' } );
897         } else {
898             ( $r, $evt ) = $U->checksesperm($authtoken, 'VIEW_TITLE_NOTES');
899             return $evt if $evt;
900             return $U->cstorereq(
901                 'open-ils.cstore.direct.biblio.record_note.search.atomic', { record => $id } );
902         }
903     }
904
905     return undef;
906 }
907
908 __PACKAGE__->register_method(
909     method  => 'has_notes',
910     api_name    => 'open-ils.circ.copy.has_notes');
911 __PACKAGE__->register_method(
912     method  => 'has_notes',
913     api_name    => 'open-ils.circ.call_number.has_notes');
914 __PACKAGE__->register_method(
915     method  => 'has_notes',
916     api_name    => 'open-ils.circ.title.has_notes');
917
918
919 sub has_notes {
920     my( $self, $conn, $authtoken, $id ) = @_;
921     my $editor = new_editor(authtoken => $authtoken);
922     return $editor->event unless $editor->checkauth;
923
924     my $n = $editor->search_asset_copy_note(
925         {owning_copy=>$id}, {idlist=>1}) if $self->api_name =~ /copy/;
926
927     $n = $editor->search_asset_call_number_note(
928         {call_number=>$id}, {idlist=>1}) if $self->api_name =~ /call_number/;
929
930     $n = $editor->search_biblio_record_note(
931         {record=>$id}, {idlist=>1}) if $self->api_name =~ /title/;
932
933     return scalar @$n;
934 }
935
936
937
938 __PACKAGE__->register_method(
939     method      => 'create_copy_note',
940     api_name        => 'open-ils.circ.copy_note.create',
941     signature   => q/
942         Creates a new copy note
943         @param authtoken The login session key
944         @param note The note object to create
945         @return The id of the new note object
946     /);
947
948 sub create_copy_note {
949     my( $self, $connection, $authtoken, $note ) = @_;
950
951     my $e = new_editor(xact=>1, authtoken=>$authtoken);
952     return $e->event unless $e->checkauth;
953     my $copy = $e->retrieve_asset_copy(
954         [
955             $note->owning_copy,
956             {   flesh => 1,
957                 flesh_fields => { 'acp' => ['call_number'] }
958             }
959         ]
960     );
961
962     return $e->event unless 
963         $e->allowed('CREATE_COPY_NOTE', $copy->call_number->owning_lib);
964
965     $note->create_date('now');
966     $note->creator($e->requestor->id);
967     $note->pub( ($U->is_true($note->pub)) ? 't' : 'f' );
968     $note->clear_id;
969
970     $e->create_asset_copy_note($note) or return $e->event;
971     $e->commit;
972     return $note->id;
973 }
974
975
976 __PACKAGE__->register_method(
977     method      => 'delete_copy_note',
978     api_name        =>  'open-ils.circ.copy_note.delete',
979     signature   => q/
980         Deletes an existing copy note
981         @param authtoken The login session key
982         @param noteid The id of the note to delete
983         @return 1 on success - Event otherwise.
984         /);
985 sub delete_copy_note {
986     my( $self, $conn, $authtoken, $noteid ) = @_;
987
988     my $e = new_editor(xact=>1, authtoken=>$authtoken);
989     return $e->die_event unless $e->checkauth;
990
991     my $note = $e->retrieve_asset_copy_note([
992         $noteid,
993         { flesh => 2,
994             flesh_fields => {
995                 'acpn' => [ 'owning_copy' ],
996                 'acp' => [ 'call_number' ],
997             }
998         }
999     ]) or return $e->die_event;
1000
1001     if( $note->creator ne $e->requestor->id ) {
1002         return $e->die_event unless 
1003             $e->allowed('DELETE_COPY_NOTE', $note->owning_copy->call_number->owning_lib);
1004     }
1005
1006     $e->delete_asset_copy_note($note) or return $e->die_event;
1007     $e->commit;
1008     return 1;
1009 }
1010
1011 __PACKAGE__->register_method(
1012     method      => 'fetch_copy_tags',
1013     authoritative   => 1,
1014     api_name        => 'open-ils.circ.copy_tags.retrieve',
1015     signature   => q/
1016         Returns an array of publicly-visible copy tag objects.  
1017         @param args A named hash of parameters including:
1018             copy_id     : The id of the item whose notes we want to retrieve
1019             tag_type    : Type of copy tags to retrieve, e.g., 'bookplate' (optional)
1020             scope       : top of org subtree whose copy tags we want to see
1021             depth       : how far down to look for copy tags (optional)
1022         @return An array of copy tag objects
1023     /);
1024 __PACKAGE__->register_method(
1025     method      => 'fetch_copy_tags',
1026     authoritative   => 1,
1027     api_name        => 'open-ils.circ.copy_tags.retrieve.staff',
1028     signature   => q/
1029         Returns an array of all copy tag objects.  
1030         @param args A named hash of parameters including:
1031             authtoken   : Required to view non-public notes
1032             copy_id     : The id of the item whose notes we want to retrieve (optional)
1033             tag_type    : Type of copy tags to retrieve, e.g., 'bookplate'
1034             scope       : top of org subtree whose copy tags we want to see
1035             depth       : how far down to look for copy tags (optional)
1036         @return An array of copy tag objects
1037     /);
1038
1039 sub fetch_copy_tags {
1040     my ($self, $conn, $args) = @_;
1041
1042     my $org = $args->{scope};
1043     my $depth = $args->{depth};
1044
1045     my $filter = {};
1046     my $e;
1047     if ($self->api_name =~ /\.staff/) {
1048         my $authtoken = $args->{authtoken};
1049         return new OpenILS::Event("BAD_PARAMS", "desc" => "authtoken required") unless defined $authtoken;    
1050         $e = new_editor(authtoken => $args->{authtoken});
1051         return $e->event unless $e->checkauth;
1052         return $e->event unless $e->allowed('STAFF_LOGIN', $org);
1053     } else {
1054         $e = new_editor();
1055         $filter->{pub} = 't';
1056     }
1057     $filter->{tag_type} = $args->{tag_type} if exists($args->{tag_type});
1058     $filter->{'+acptcm'} = {
1059         copy => $args->{copy_id}
1060     };
1061
1062     # filter by owner of copy tag and depth
1063     $filter->{owner} = {
1064         in => {
1065             select => {aou => [{
1066                 column => 'id',
1067                 transform => 'actor.org_unit_descendants',
1068                 result_field => 'id',
1069                 (defined($depth) ? ( params => [$depth] ) : ()),
1070             }]},
1071             from => 'aou',
1072             where => {id => $org}
1073         }
1074     };
1075
1076     return $e->search_asset_copy_tag([$filter, { join => { acptcm => {} } }]);
1077 }
1078
1079
1080 __PACKAGE__->register_method(
1081     method => 'age_hold_rules',
1082     api_name    =>  'open-ils.circ.config.rules.age_hold_protect.retrieve.all',
1083 );
1084
1085 sub age_hold_rules {
1086     my( $self, $conn ) = @_;
1087     return new_editor()->retrieve_all_config_rules_age_hold_protect();
1088 }
1089
1090
1091
1092 __PACKAGE__->register_method(
1093     method => 'copy_details_barcode',
1094     authoritative => 1,
1095     api_name => 'open-ils.circ.copy_details.retrieve.barcode');
1096 sub copy_details_barcode {
1097     my( $self, $conn, $auth, $barcode ) = @_;
1098     my $e = new_editor();
1099     my $cid = $e->search_asset_copy({barcode=>$barcode, deleted=>'f'}, {idlist=>1})->[0];
1100     return $e->event unless $cid;
1101     return copy_details( $self, $conn, $auth, $cid );
1102 }
1103
1104
1105 __PACKAGE__->register_method(
1106     method => 'copy_details',
1107     api_name => 'open-ils.circ.copy_details.retrieve');
1108
1109 sub copy_details {
1110     my( $self, $conn, $auth, $copy_id ) = @_;
1111     my $e = new_editor(authtoken=>$auth);
1112     return $e->event unless $e->checkauth;
1113
1114     my $flesh = { flesh => 1 };
1115
1116     my $copy = $e->retrieve_asset_copy(
1117         [
1118             $copy_id,
1119             {
1120                 flesh => 2,
1121                 flesh_fields => {
1122                     acp => ['call_number','parts','peer_record_maps','floating'],
1123                     acn => ['record','prefix','suffix','label_class']
1124                 }
1125             }
1126         ]) or return $e->event;
1127
1128
1129     # De-flesh the copy for backwards compatibility
1130     my $mvr;
1131     my $vol = $copy->call_number;
1132     if( ref $vol ) {
1133         $copy->call_number($vol->id);
1134         my $record = $vol->record;
1135         if( ref $record ) {
1136             $vol->record($record->id);
1137             $mvr = $U->record_to_mvr($record);
1138         }
1139     }
1140
1141
1142     my $hold = $e->search_action_hold_request(
1143         { 
1144             current_copy        => $copy_id, 
1145             capture_time        => { "!=" => undef },
1146             fulfillment_time    => undef,
1147             cancel_time         => undef,
1148         }
1149     )->[0];
1150
1151     OpenILS::Application::Circ::Holds::flesh_hold_transits([$hold]) if $hold;
1152
1153     my $transit = $e->search_action_transit_copy(
1154         { target_copy => $copy_id, dest_recv_time => undef, cancel_time => undef } )->[0];
1155
1156     # find the most recent circulation for the requested copy,
1157     # be it active, completed, or aged.
1158     my $circ = $e->search_action_all_circulation_slim([
1159         { target_copy => $copy_id },
1160         {
1161             flesh => 1,
1162             flesh_fields => {
1163                 aacs => [
1164                     'workstation',
1165                     'checkin_workstation',
1166                     'duration_rule',
1167                     'max_fine_rule',
1168                     'recurring_fine_rule'
1169                 ],
1170             },
1171             order_by => { aacs => 'xact_start desc' },
1172             limit => 1
1173         }
1174     ])->[0];
1175
1176     return {
1177         copy    => $copy,
1178         hold    => $hold,
1179         transit => $transit,
1180         circ    => $circ,
1181         volume  => $vol,
1182         mvr     => $mvr
1183     };
1184 }
1185
1186
1187
1188
1189 __PACKAGE__->register_method(
1190     method => 'mark_item',
1191     api_name => 'open-ils.circ.mark_item_damaged',
1192     signature   => q/
1193         Changes the status of a copy to "damaged". Requires MARK_ITEM_DAMAGED permission.
1194         @param authtoken The login session key
1195         @param copy_id The ID of the copy to mark as damaged
1196         @return 1 on success - Event otherwise.
1197         /
1198 );
1199 __PACKAGE__->register_method(
1200     method => 'mark_item',
1201     api_name => 'open-ils.circ.mark_item_missing',
1202     signature   => q/
1203         Changes the status of a copy to "missing". Requires MARK_ITEM_MISSING permission.
1204         @param authtoken The login session key
1205         @param copy_id The ID of the copy to mark as missing 
1206         @return 1 on success - Event otherwise.
1207         /
1208 );
1209 __PACKAGE__->register_method(
1210     method => 'mark_item',
1211     api_name => 'open-ils.circ.mark_item_bindery',
1212     signature   => q/
1213         Changes the status of a copy to "bindery". Requires MARK_ITEM_BINDERY permission.
1214         @param authtoken The login session key
1215         @param copy_id The ID of the copy to mark as bindery
1216         @return 1 on success - Event otherwise.
1217         /
1218 );
1219 __PACKAGE__->register_method(
1220     method => 'mark_item',
1221     api_name => 'open-ils.circ.mark_item_on_order',
1222     signature   => q/
1223         Changes the status of a copy to "on order". Requires MARK_ITEM_ON_ORDER permission.
1224         @param authtoken The login session key
1225         @param copy_id The ID of the copy to mark as on order 
1226         @return 1 on success - Event otherwise.
1227         /
1228 );
1229 __PACKAGE__->register_method(
1230     method => 'mark_item',
1231     api_name => 'open-ils.circ.mark_item_ill',
1232     signature   => q/
1233         Changes the status of a copy to "inter-library loan". Requires MARK_ITEM_ILL permission.
1234         @param authtoken The login session key
1235         @param copy_id The ID of the copy to mark as inter-library loan
1236         @return 1 on success - Event otherwise.
1237         /
1238 );
1239 __PACKAGE__->register_method(
1240     method => 'mark_item',
1241     api_name => 'open-ils.circ.mark_item_cataloging',
1242     signature   => q/
1243         Changes the status of a copy to "cataloging". Requires MARK_ITEM_CATALOGING permission.
1244         @param authtoken The login session key
1245         @param copy_id The ID of the copy to mark as cataloging 
1246         @return 1 on success - Event otherwise.
1247         /
1248 );
1249 __PACKAGE__->register_method(
1250     method => 'mark_item',
1251     api_name => 'open-ils.circ.mark_item_reserves',
1252     signature   => q/
1253         Changes the status of a copy to "reserves". Requires MARK_ITEM_RESERVES permission.
1254         @param authtoken The login session key
1255         @param copy_id The ID of the copy to mark as reserves
1256         @return 1 on success - Event otherwise.
1257         /
1258 );
1259 __PACKAGE__->register_method(
1260     method => 'mark_item',
1261     api_name => 'open-ils.circ.mark_item_discard',
1262     signature   => q/
1263         Changes the status of a copy to "discard". Requires MARK_ITEM_DISCARD permission.
1264         @param authtoken The login session key
1265         @param copy_id The ID of the copy to mark as discard
1266         @return 1 on success - Event otherwise.
1267         /
1268 );
1269
1270 sub mark_item {
1271     my( $self, $conn, $auth, $copy_id, $args ) = @_;
1272     $args ||= {};
1273
1274     # Items must be checked in before any attempt is made to mark damaged
1275     my $evt = try_checkin($auth, $copy_id) if
1276         ($self->api_name=~ /damaged/ && $args->{handle_checkin});
1277     return $evt if $evt;
1278
1279     my $e = new_editor(authtoken=>$auth, xact =>1);
1280     return $e->die_event unless $e->checkauth;
1281     my $copy = $e->retrieve_asset_copy([
1282         $copy_id,
1283         {flesh => 1, flesh_fields => {'acp' => ['call_number']}}])
1284             or return $e->die_event;
1285
1286     my $owning_lib = 
1287         ($copy->call_number->id == OILS_PRECAT_CALL_NUMBER) ? 
1288             $copy->circ_lib : $copy->call_number->owning_lib;
1289
1290     my $perm = 'MARK_ITEM_MISSING';
1291     my $stat = OILS_COPY_STATUS_MISSING;
1292
1293     if( $self->api_name =~ /damaged/ ) {
1294         $perm = 'MARK_ITEM_DAMAGED';
1295         $stat = OILS_COPY_STATUS_DAMAGED;
1296         my $evt = handle_mark_damaged($e, $copy, $owning_lib, $args);
1297         return $evt if $evt;
1298
1299     } elsif ( $self->api_name =~ /bindery/ ) {
1300         $perm = 'MARK_ITEM_BINDERY';
1301         $stat = OILS_COPY_STATUS_BINDERY;
1302     } elsif ( $self->api_name =~ /on_order/ ) {
1303         $perm = 'MARK_ITEM_ON_ORDER';
1304         $stat = OILS_COPY_STATUS_ON_ORDER;
1305     } elsif ( $self->api_name =~ /ill/ ) {
1306         $perm = 'MARK_ITEM_ILL';
1307         $stat = OILS_COPY_STATUS_ILL;
1308     } elsif ( $self->api_name =~ /cataloging/ ) {
1309         $perm = 'MARK_ITEM_CATALOGING';
1310         $stat = OILS_COPY_STATUS_CATALOGING;
1311     } elsif ( $self->api_name =~ /reserves/ ) {
1312         $perm = 'MARK_ITEM_RESERVES';
1313         $stat = OILS_COPY_STATUS_RESERVES;
1314     } elsif ( $self->api_name =~ /discard/ ) {
1315         $perm = 'MARK_ITEM_DISCARD';
1316         $stat = OILS_COPY_STATUS_DISCARD;
1317     }
1318
1319     # caller may proceed if either perm is allowed
1320     return $e->die_event unless $e->allowed([$perm, 'UPDATE_COPY'], $owning_lib);
1321
1322     $copy->status($stat);
1323     $copy->edit_date('now');
1324     $copy->editor($e->requestor->id);
1325
1326     $e->update_asset_copy($copy) or return $e->die_event;
1327
1328     my $holds = $e->search_action_hold_request(
1329         { 
1330             current_copy => $copy->id,
1331             fulfillment_time => undef,
1332             cancel_time => undef,
1333         }
1334     );
1335
1336     $e->commit;
1337
1338     if( $self->api_name =~ /damaged/ ) {
1339         # now that we've committed the changes, create related A/T events
1340         my $ses = OpenSRF::AppSession->create('open-ils.trigger');
1341         $ses->request('open-ils.trigger.event.autocreate', 'damaged', $copy, $owning_lib);
1342     }
1343
1344     $logger->debug("resetting holds that target the marked copy");
1345     OpenILS::Application::Circ::Holds->_reset_hold($e->requestor, $_) for @$holds;
1346
1347     return 1;
1348 }
1349
1350 sub try_checkin {
1351     my($auth, $copy_id) = @_;
1352
1353     my $checkin = $U->simplereq(
1354         'open-ils.circ',
1355         'open-ils.circ.checkin.override',
1356         $auth, {
1357             copy_id => $copy_id,
1358             noop => 1
1359         }
1360     );
1361     if(ref $checkin ne 'ARRAY') { $checkin = [$checkin]; }
1362
1363     my $evt_code = $checkin->[0]->{textcode};
1364     $logger->info("try_checkin() received event: $evt_code");
1365
1366     if($evt_code eq 'SUCCESS' || $evt_code eq 'NO_CHANGE') {
1367         $logger->info('try_checkin() successful checkin');
1368         return undef;
1369     } else {
1370         $logger->warn('try_checkin() un-successful checkin');
1371         return $checkin;
1372     }
1373 }
1374
1375 sub handle_mark_damaged {
1376     my($e, $copy, $owning_lib, $args) = @_;
1377
1378     my $apply = $args->{apply_fines} || '';
1379     return undef if $apply eq 'noapply';
1380
1381     my $new_amount = $args->{override_amount};
1382     my $new_btype = $args->{override_btype};
1383     my $new_note = $args->{override_note};
1384
1385     # grab the last circulation
1386     my $circ = $e->search_action_circulation([
1387         {   target_copy => $copy->id}, 
1388         {   limit => 1, 
1389             order_by => {circ => "xact_start DESC"},
1390             flesh => 2,
1391             flesh_fields => {circ => ['target_copy', 'usr'], au => ['card']}
1392         }
1393     ])->[0];
1394
1395     return undef unless $circ;
1396
1397     my $charge_price = $U->ou_ancestor_setting_value(
1398         $owning_lib, 'circ.charge_on_damaged', $e);
1399
1400     my $proc_fee = $U->ou_ancestor_setting_value(
1401         $owning_lib, 'circ.damaged_item_processing_fee', $e) || 0;
1402
1403     my $void_overdue = $U->ou_ancestor_setting_value(
1404         $owning_lib, 'circ.damaged.void_ovedue', $e) || 0;
1405
1406     return undef unless $charge_price or $proc_fee;
1407
1408     my $copy_price = ($charge_price) ? $U->get_copy_price($e, $copy) : 0;
1409     my $total = $copy_price + $proc_fee;
1410
1411     if($apply) {
1412         
1413         if($new_amount and $new_btype) {
1414
1415             # Allow staff to override the amount to charge for a damaged item
1416             # Consider the case where the item is only partially damaged
1417             # This value is meant to take the place of the item price and
1418             # optional processing fee.
1419
1420             my $evt = OpenILS::Application::Circ::CircCommon->create_bill(
1421                 $e, $new_amount, $new_btype, 'Damaged Item Override', $circ->id, $new_note);
1422             return $evt if $evt;
1423
1424         } else {
1425
1426             if($charge_price and $copy_price) {
1427                 my $evt = OpenILS::Application::Circ::CircCommon->create_bill(
1428                     $e, $copy_price, 7, 'Damaged Item', $circ->id);
1429                 return $evt if $evt;
1430             }
1431
1432             if($proc_fee) {
1433                 my $evt = OpenILS::Application::Circ::CircCommon->create_bill(
1434                     $e, $proc_fee, 8, 'Damaged Item Processing Fee', $circ->id);
1435                 return $evt if $evt;
1436             }
1437         }
1438
1439         # the assumption is that you would not void the overdues unless you 
1440         # were also charging for the item and/or applying a processing fee
1441         if($void_overdue) {
1442             my $evt = OpenILS::Application::Circ::CircCommon->void_or_zero_overdues($e, $circ, {note => 'System: OVERDUE REVERSED FOR DAMAGE CHARGE'});
1443             return $evt if $evt;
1444         }
1445
1446         my $evt = OpenILS::Application::Circ::CircCommon->reopen_xact($e, $circ->id);
1447         return $evt if $evt;
1448
1449         my $ses = OpenSRF::AppSession->create('open-ils.trigger');
1450         $ses->request('open-ils.trigger.event.autocreate', 'checkout.damaged', $circ, $circ->circ_lib);
1451
1452         my $evt2 = OpenILS::Utils::Penalty->calculate_penalties($e, $circ->usr->id, $e->requestor->ws_ou);
1453         return $evt2 if $evt2;
1454
1455     } else {
1456         return OpenILS::Event->new('DAMAGE_CHARGE', 
1457             payload => {
1458                 circ => $circ,
1459                 charge => $total
1460             }
1461         );
1462     }
1463 }
1464
1465
1466
1467 # ----------------------------------------------------------------------
1468 __PACKAGE__->register_method(
1469     method => 'mark_item_missing_pieces',
1470     api_name => 'open-ils.circ.mark_item_missing_pieces',
1471     signature   => q/
1472         Changes the status of a copy to "damaged" or to a custom status based on the 
1473         circ.missing_pieces.copy_status org unit setting. Requires MARK_ITEM_MISSING_PIECES
1474         permission.
1475         @param authtoken The login session key
1476         @param copy_id The ID of the copy to mark as damaged
1477         @return Success event with circ and copy objects in the payload, or error Event otherwise.
1478         /
1479 );
1480
1481 sub mark_item_missing_pieces {
1482     my( $self, $conn, $auth, $copy_id, $args ) = @_;
1483     ### FIXME: We're starting a transaction here, but we're doing a lot of things outside of the transaction
1484     ### FIXME: Even better, we're going to use two transactions, the first to affect pertinent holds before checkout can
1485
1486     my $e2 = new_editor(authtoken=>$auth, xact =>1);
1487     return $e2->die_event unless $e2->checkauth;
1488     $args ||= {};
1489
1490     my $copy = $e2->retrieve_asset_copy([
1491         $copy_id,
1492         {flesh => 1, flesh_fields => {'acp' => ['call_number']}}])
1493             or return $e2->die_event;
1494
1495     my $owning_lib = 
1496         ($copy->call_number->id == OILS_PRECAT_CALL_NUMBER) ? 
1497             $copy->circ_lib : $copy->call_number->owning_lib;
1498
1499     return $e2->die_event unless $e2->allowed('MARK_ITEM_MISSING_PIECES', $owning_lib);
1500
1501     #### grab the last circulation
1502     my $circ = $e2->search_action_circulation([
1503         {   target_copy => $copy->id}, 
1504         {   limit => 1, 
1505             order_by => {circ => "xact_start DESC"}
1506         }
1507     ])->[0];
1508
1509     if (!$circ) {
1510         $logger->info('open-ils.circ.mark_item_missing_pieces: no previous checkout');
1511         $e2->rollback;
1512         return OpenILS::Event->new('ACTION_CIRCULATION_NOT_FOUND',{'copy'=>$copy});
1513     }
1514
1515     my $holds = $e2->search_action_hold_request(
1516         { 
1517             current_copy => $copy->id,
1518             fulfillment_time => undef,
1519             cancel_time => undef,
1520         }
1521     );
1522
1523     $logger->debug("resetting holds that target the marked copy");
1524     OpenILS::Application::Circ::Holds->_reset_hold($e2->requestor, $_) for @$holds;
1525
1526     
1527     if (! $e2->commit) {
1528         return $e2->die_event;
1529     }
1530
1531     my $e = new_editor(authtoken=>$auth, xact =>1);
1532     return $e->die_event unless $e->checkauth;
1533
1534     if (! $circ->checkin_time) { # if circ active, attempt renew
1535         my ($res) = $self->method_lookup('open-ils.circ.renew')->run($e->authtoken,{'copy_id'=>$circ->target_copy});
1536         if (ref $res ne 'ARRAY') { $res = [ $res ]; }
1537         if ( $res->[0]->{textcode} eq 'SUCCESS' ) {
1538             $circ = $res->[0]->{payload}{'circ'};
1539             $circ->target_copy( $copy->id );
1540             $logger->info('open-ils.circ.mark_item_missing_pieces: successful renewal');
1541         } else {
1542             $logger->info('open-ils.circ.mark_item_missing_pieces: non-successful renewal');
1543         }
1544     } else {
1545
1546         my $co_params = {
1547             'copy_id'=>$circ->target_copy,
1548             'patron_id'=>$circ->usr,
1549             'skip_deposit_fee'=>1,
1550             'skip_rental_fee'=>1
1551         };
1552
1553         if ($U->ou_ancestor_setting_value($e->requestor->ws_ou, 'circ.block_renews_for_holds')) {
1554
1555             my ($hold, undef, $retarget) = $holdcode->find_nearest_permitted_hold(
1556                 $e, $copy, $e->requestor, 1 );
1557
1558             if ($hold) { # needed for hold? then due now
1559
1560                 $logger->info('open-ils.circ.mark_item_missing_pieces: item needed for hold, shortening due date');
1561                 my $due_date = DateTime->now(time_zone => 'local');
1562                 $co_params->{'due_date'} = cleanse_ISO8601( $due_date->strftime('%FT%T%z') );
1563             } else {
1564                 $logger->info('open-ils.circ.mark_item_missing_pieces: item not needed for hold');
1565             }
1566         }
1567
1568         my ($res) = $self->method_lookup('open-ils.circ.checkout.full.override')->run($e->authtoken,$co_params,{ all => 1 });
1569         if (ref $res ne 'ARRAY') { $res = [ $res ]; }
1570         if ( $res->[0]->{textcode} eq 'SUCCESS' ) {
1571             $logger->info('open-ils.circ.mark_item_missing_pieces: successful checkout');
1572             $circ = $res->[0]->{payload}{'circ'};
1573         } else {
1574             $logger->info('open-ils.circ.mark_item_missing_pieces: non-successful checkout');
1575             $e->rollback;
1576             return $res;
1577         }
1578     }
1579
1580     ### Update the item status
1581
1582     my $custom_stat = $U->ou_ancestor_setting_value(
1583         $owning_lib, 'circ.missing_pieces.copy_status', $e);
1584     my $stat = $custom_stat || OILS_COPY_STATUS_DAMAGED;
1585
1586     my $ses = OpenSRF::AppSession->create('open-ils.trigger');
1587     $ses->request('open-ils.trigger.event.autocreate', 'missing_pieces', $copy, $owning_lib);
1588
1589     $copy->status($stat);
1590     $copy->edit_date('now');
1591     $copy->editor($e->requestor->id);
1592
1593     $e->update_asset_copy($copy) or return $e->die_event;
1594
1595     if ($e->commit) {
1596
1597         my $ses = OpenSRF::AppSession->create('open-ils.trigger');
1598         $ses->request('open-ils.trigger.event.autocreate', 'circ.missing_pieces', $circ, $circ->circ_lib);
1599
1600         return OpenILS::Event->new('SUCCESS',
1601             payload => {
1602                 circ => $circ,
1603                 copy => $copy,
1604                 slip => $U->fire_object_event(undef, 'circ.format.missing_pieces.slip.print', $circ, $circ->circ_lib),
1605                 letter => $U->fire_object_event(undef, 'circ.format.missing_pieces.letter.print', $circ, $circ->circ_lib)
1606             }
1607         ); 
1608
1609     } else {
1610         return $e->die_event;
1611     }
1612 }
1613
1614
1615
1616
1617
1618 # ----------------------------------------------------------------------
1619 __PACKAGE__->register_method(
1620     method => 'magic_fetch',
1621     api_name => 'open-ils.agent.fetch'
1622 );
1623
1624 my @FETCH_ALLOWED = qw/ aou aout acp acn bre /;
1625
1626 sub magic_fetch {
1627     my( $self, $conn, $auth, $args ) = @_;
1628     my $e = new_editor( authtoken => $auth );
1629     return $e->event unless $e->checkauth;
1630
1631     my $hint = $$args{hint};
1632     my $id  = $$args{id};
1633
1634     # Is the call allowed to fetch this type of object?
1635     return undef unless grep { $_ eq $hint } @FETCH_ALLOWED;
1636
1637     # Find the class the implements the given hint
1638     my ($class) = grep { 
1639         $Fieldmapper::fieldmap->{$_}{hint} eq $hint } Fieldmapper->classes;
1640
1641     $class =~ s/Fieldmapper:://og;
1642     $class =~ s/::/_/og;
1643     my $method = "retrieve_$class";
1644
1645     my $obj = $e->$method($id) or return $e->event;
1646     return $obj;
1647 }
1648 # ----------------------------------------------------------------------
1649
1650
1651 __PACKAGE__->register_method(
1652     method  => "fleshed_circ_retrieve",
1653     authoritative => 1,
1654     api_name    => "open-ils.circ.fleshed.retrieve",);
1655
1656 sub fleshed_circ_retrieve {
1657     my( $self, $client, $id ) = @_;
1658     my $e = new_editor();
1659     my $circ = $e->retrieve_action_circulation(
1660         [
1661             $id,
1662             { 
1663                 flesh               => 4,
1664                 flesh_fields    => { 
1665                     circ => [ qw/ target_copy / ],
1666                     acp => [ qw/ location status stat_cat_entry_copy_maps notes age_protect call_number parts / ],
1667                     ascecm => [ qw/ stat_cat stat_cat_entry / ],
1668                     acn => [ qw/ record / ],
1669                 }
1670             }
1671         ]
1672     ) or return $e->event;
1673     
1674     my $copy = $circ->target_copy;
1675     my $vol = $copy->call_number;
1676     my $rec = $circ->target_copy->call_number->record;
1677
1678     $vol->record($rec->id);
1679     $copy->call_number($vol->id);
1680     $circ->target_copy($copy->id);
1681
1682     my $mvr;
1683
1684     if( $rec->id == OILS_PRECAT_RECORD ) {
1685         $rec = undef;
1686         $vol = undef;
1687     } else { 
1688         $mvr = $U->record_to_mvr($rec);
1689         $rec->marc(''); # drop the bulky marc data
1690     }
1691
1692     return {
1693         circ => $circ,
1694         copy => $copy,
1695         volume => $vol,
1696         record => $rec,
1697         mvr => $mvr,
1698     };
1699 }
1700
1701
1702
1703 __PACKAGE__->register_method(
1704     method  => "test_batch_circ_events",
1705     api_name    => "open-ils.circ.trigger_event_by_def_and_barcode.fire"
1706 );
1707
1708 #  method for testing the behavior of a given event definition
1709 sub test_batch_circ_events {
1710     my($self, $conn, $auth, $event_def, $barcode) = @_;
1711
1712     my $e = new_editor(authtoken => $auth);
1713     return $e->event unless $e->checkauth;
1714     return $e->event unless $e->allowed('VIEW_CIRCULATIONS');
1715
1716     my $copy = $e->search_asset_copy({barcode => $barcode, deleted => 'f'})->[0]
1717         or return $e->event;
1718
1719     my $circ = $e->search_action_circulation(
1720         {target_copy => $copy->id, checkin_time => undef})->[0]
1721         or return $e->event;
1722         
1723     return undef unless $circ;
1724
1725     return $U->fire_object_event($event_def, undef, $circ, $e->requestor->ws_ou)
1726 }
1727
1728
1729 __PACKAGE__->register_method(
1730     method  => "fire_circ_events", 
1731     api_name    => "open-ils.circ.fire_circ_trigger_events",
1732     signature => q/
1733         General event def runner for circ objects.  If no event def ID
1734         is provided, the hook will be used to find the best event_def
1735         match based on the context org unit
1736     /
1737 );
1738
1739 __PACKAGE__->register_method(
1740     method  => "fire_circ_events", 
1741     api_name    => "open-ils.circ.fire_hold_trigger_events",
1742     signature => q/
1743         General event def runner for hold objects.  If no event def ID
1744         is provided, the hook will be used to find the best event_def
1745         match based on the context org unit
1746     /
1747 );
1748
1749 __PACKAGE__->register_method(
1750     method  => "fire_circ_events", 
1751     api_name    => "open-ils.circ.fire_user_trigger_events",
1752     signature => q/
1753         General event def runner for user objects.  If no event def ID
1754         is provided, the hook will be used to find the best event_def
1755         match based on the context org unit
1756     /
1757 );
1758
1759
1760 sub fire_circ_events {
1761     my($self, $conn, $auth, $org_id, $event_def, $hook, $granularity, $target_ids, $user_data) = @_;
1762
1763     my $e = new_editor(authtoken => $auth, xact => 1);
1764     return $e->event unless $e->checkauth;
1765
1766     my $targets;
1767
1768     if($self->api_name =~ /hold/) {
1769         return $e->event unless $e->allowed('VIEW_HOLD', $org_id);
1770         $targets = $e->batch_retrieve_action_hold_request($target_ids);
1771     } elsif($self->api_name =~ /user/) {
1772         return $e->event unless $e->allowed('VIEW_USER', $org_id);
1773         $targets = $e->batch_retrieve_actor_user($target_ids);
1774     } else {
1775         return $e->event unless $e->allowed('VIEW_CIRCULATIONS', $org_id);
1776         $targets = $e->batch_retrieve_action_circulation($target_ids);
1777     }
1778     $e->rollback; # FIXME using transaction because of pgpool/slony setups, but not
1779                   # simply making this method authoritative because of weirdness
1780                   # with transaction handling in A/T code that causes rollback
1781                   # failure down the line if handling many targets
1782
1783     return undef unless @$targets;
1784     return $U->fire_object_event($event_def, $hook, $targets, $org_id, $granularity, $user_data);
1785 }
1786
1787 __PACKAGE__->register_method(
1788     method  => "user_payments_list",
1789     api_name    => "open-ils.circ.user_payments.filtered.batch",
1790     stream => 1,
1791     signature => {
1792         desc => q/Returns a fleshed, date-limited set of all payments a user
1793                 has made.  By default, ordered by payment date.  Optionally
1794                 ordered by other columns in the top-level "mp" object/,
1795         params => [
1796             {desc => 'Authentication token', type => 'string'},
1797             {desc => 'User ID', type => 'number'},
1798             {desc => 'Order by column(s), optional.  Array of "mp" class columns', type => 'array'}
1799         ],
1800         return => {desc => q/List of "mp" objects, fleshed with the billable transaction 
1801             and the related fully-realized payment object (e.g money.cash_payment)/}
1802     }
1803 );
1804
1805 sub user_payments_list {
1806     my($self, $conn, $auth, $user_id, $start_date, $end_date, $order_by) = @_;
1807
1808     my $e = new_editor(authtoken => $auth);
1809     return $e->event unless $e->checkauth;
1810
1811     my $user = $e->retrieve_actor_user($user_id) or return $e->event;
1812     return $e->event unless $e->allowed('VIEW_CIRCULATIONS', $user->home_ou);
1813
1814     $order_by ||= ['payment_ts'];
1815
1816     # all payments by user, between start_date and end_date
1817     my $payments = $e->json_query({
1818         select => {mp => ['id']}, 
1819         from => {
1820             mp => {
1821                 mbt => {
1822                     fkey => 'xact', field => 'id'}
1823             }
1824         }, 
1825         where => {
1826             '+mbt' => {usr => $user_id}, 
1827             '+mp' => {payment_ts => {between => [$start_date, $end_date]}}
1828         },
1829         order_by => {mp => $order_by}
1830     });
1831
1832     for my $payment_id (@$payments) {
1833         my $payment = $e->retrieve_money_payment([
1834             $payment_id->{id}, 
1835             {   
1836                 flesh => 2,
1837                 flesh_fields => {
1838                     mp => [
1839                         'xact',
1840                         'cash_payment',
1841                         'credit_card_payment',
1842                         'credit_payment',
1843                         'check_payment',
1844                         'work_payment',
1845                         'forgive_payment',
1846                         'goods_payment'
1847                     ],
1848                     mbt => [
1849                         'circulation', 
1850                         'grocery',
1851                         'reservation'
1852                     ]
1853                 }
1854             }
1855         ]);
1856         $conn->respond($payment);
1857     }
1858
1859     return undef;
1860 }
1861
1862
1863 __PACKAGE__->register_method(
1864     method  => "retrieve_circ_chain",
1865     api_name    => "open-ils.circ.renewal_chain.retrieve_by_circ",
1866     stream => 1,
1867     signature => {
1868         desc => q/Given a circulation, this returns all circulation objects
1869                 that are part of the same chain of renewals./,
1870         params => [
1871             {desc => 'Authentication token', type => 'string'},
1872             {desc => 'Circ ID', type => 'number'},
1873         ],
1874         return => {desc => q/List of circ objects, orderd by oldest circ first/}
1875     }
1876 );
1877
1878 __PACKAGE__->register_method(
1879     method  => "retrieve_circ_chain",
1880     api_name    => "open-ils.circ.renewal_chain.retrieve_by_circ.summary",
1881     signature => {
1882         desc => q/Given a circulation, this returns a summary of the circulation objects
1883                 that are part of the same chain of renewals./,
1884         params => [
1885             {desc => 'Authentication token', type => 'string'},
1886             {desc => 'Circ ID', type => 'number'},
1887         ],
1888         return => {desc => q/Circulation Chain Summary/}
1889     }
1890 );
1891
1892 sub retrieve_circ_chain {
1893     my($self, $conn, $auth, $circ_id) = @_;
1894
1895     my $e = new_editor(authtoken => $auth);
1896     return $e->event unless $e->checkauth;
1897     return $e->event unless $e->allowed('VIEW_CIRCULATIONS');
1898
1899     if($self->api_name =~ /summary/) {
1900         return $U->create_circ_chain_summary($e, $circ_id);
1901
1902     } else {
1903
1904         my $chain = $e->json_query({from => ['action.all_circ_chain', $circ_id]});
1905
1906         for my $circ_info (@$chain) {
1907             my $circ = Fieldmapper::action::all_circulation_slim->new;
1908             $circ->$_($circ_info->{$_}) for keys %$circ_info;
1909             $conn->respond($circ);
1910         }
1911     }
1912
1913     return undef;
1914 }
1915
1916 __PACKAGE__->register_method(
1917     method  => "retrieve_prev_circ_chain",
1918     api_name    => "open-ils.circ.prev_renewal_chain.retrieve_by_circ",
1919     stream => 1,
1920     signature => {
1921         desc => q/Given a circulation, this returns all circulation objects
1922                 that are part of the previous chain of renewals./,
1923         params => [
1924             {desc => 'Authentication token', type => 'string'},
1925             {desc => 'Circ ID', type => 'number'},
1926         ],
1927         return => {desc => q/List of circ objects, orderd by oldest circ first/}
1928     }
1929 );
1930
1931 __PACKAGE__->register_method(
1932     method  => "retrieve_prev_circ_chain",
1933     api_name    => "open-ils.circ.prev_renewal_chain.retrieve_by_circ.summary",
1934     signature => {
1935         desc => q/Given a circulation, this returns a summary of the circulation objects
1936                 that are part of the previous chain of renewals./,
1937         params => [
1938             {desc => 'Authentication token', type => 'string'},
1939             {desc => 'Circ ID', type => 'number'},
1940         ],
1941         return => {desc => q/Object containing Circulation Chain Summary and User Id/}
1942     }
1943 );
1944
1945 sub retrieve_prev_circ_chain {
1946     my($self, $conn, $auth, $circ_id) = @_;
1947
1948     my $e = new_editor(authtoken => $auth);
1949     return $e->event unless $e->checkauth;
1950     return $e->event unless $e->allowed('VIEW_CIRCULATIONS');
1951
1952     my $first_circ = 
1953         $e->json_query({from => ['action.all_circ_chain', $circ_id]})->[0];
1954
1955     my $prev_circ = $e->search_action_all_circulation_slim([
1956         {   target_copy => $first_circ->{target_copy},
1957             xact_start => {'<' => $first_circ->{xact_start}}
1958         }, {   
1959             flesh => 1,
1960             flesh_fields => {
1961                 aacs => [
1962                     'active_circ',
1963                     'aged_circ'
1964                 ]
1965             },
1966             order_by => { aacs => 'xact_start desc' },
1967             limit => 1 
1968         }
1969     ])->[0];
1970
1971     return undef unless $prev_circ;
1972
1973     my $chain_usr = $prev_circ->usr; # note: may be undef
1974
1975     if ($self->api_name =~ /summary/) {
1976         my $sum = $e->json_query({
1977             from => [
1978                 'action.summarize_all_circ_chain', 
1979                 $prev_circ->id
1980             ]
1981         })->[0];
1982
1983         my $summary = Fieldmapper::action::circ_chain_summary->new;
1984         $summary->$_($sum->{$_}) for keys %$sum;
1985
1986         return {summary => $summary, usr => $chain_usr};
1987     }
1988
1989
1990     my $chain = $e->json_query(
1991         {from => ['action.all_circ_chain', $prev_circ->id]});
1992
1993     for my $circ_info (@$chain) {
1994         my $circ = Fieldmapper::action::all_circulation_slim->new;
1995         $circ->$_($circ_info->{$_}) for keys %$circ_info;
1996         $conn->respond($circ);
1997     }
1998
1999     return undef;
2000 }
2001
2002
2003 __PACKAGE__->register_method(
2004     method  => "get_copy_due_date",
2005     api_name    => "open-ils.circ.copy.due_date.retrieve",
2006     signature => {
2007         desc => q/
2008             Given a copy ID, returns the due date for the copy if it's 
2009             currently circulating.  Otherwise, returns null.  Note, this is a public 
2010             method requiring no authentication.  Only the due date is exposed.
2011             /,
2012         params => [
2013             {desc => 'Copy ID', type => 'number'}
2014         ],
2015         return => {desc => q/
2016             Due date (ISO date stamp) if the copy is circulating, null otherwise.
2017         /}
2018     }
2019 );
2020
2021 sub get_copy_due_date {
2022     my($self, $conn, $copy_id) = @_;
2023     my $e = new_editor();
2024
2025     my $circ = $e->json_query({
2026         select => {circ => ['due_date']},
2027         from => 'circ',
2028         where => {
2029             target_copy => $copy_id,
2030             checkin_time => undef,
2031             '-or' => [
2032                 {stop_fines => ["MAXFINES","LONGOVERDUE"]},
2033                 {stop_fines => undef}
2034             ],
2035         },
2036         limit => 1
2037     })->[0] or return undef;
2038
2039     return $circ->{due_date};
2040 }
2041
2042
2043
2044
2045
2046 # {"select":{"acp":["id"],"circ":[{"aggregate":true,"transform":"count","alias":"count","column":"id"}]},"from":{"acp":{"circ":{"field":"target_copy","fkey":"id","type":"left"},"acn"{"field":"id","fkey":"call_number"}}},"where":{"+acn":{"record":200057}}
2047
2048
2049 1;