LP#1694529 Claims returned updates patron last-xact-id
[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 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' :
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([
798         {target_copy => $copyid}, 
799         {limit => $count, order_by => { combcirc => "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([
1159         { target_copy => $copy_id },
1160         {
1161             flesh => 1,
1162             flesh_fields => {
1163                 combcirc => [
1164                     'workstation',
1165                     'checkin_workstation',
1166                     'duration_rule',
1167                     'max_fine_rule',
1168                     'recurring_fine_rule'
1169                 ],
1170             },
1171             order_by => { combcirc => '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     my $e = new_editor(authtoken=>$auth, xact =>1);
1273     return $e->die_event unless $e->checkauth;
1274     $args ||= {};
1275
1276     my $copy = $e->retrieve_asset_copy([
1277         $copy_id,
1278         {flesh => 1, flesh_fields => {'acp' => ['call_number']}}])
1279             or return $e->die_event;
1280
1281     my $owning_lib = 
1282         ($copy->call_number->id == OILS_PRECAT_CALL_NUMBER) ? 
1283             $copy->circ_lib : $copy->call_number->owning_lib;
1284
1285     my $perm = 'MARK_ITEM_MISSING';
1286     my $stat = OILS_COPY_STATUS_MISSING;
1287
1288     if( $self->api_name =~ /damaged/ ) {
1289         $perm = 'MARK_ITEM_DAMAGED';
1290         $stat = OILS_COPY_STATUS_DAMAGED;
1291         my $evt = handle_mark_damaged($e, $copy, $owning_lib, $args);
1292         return $evt if $evt;
1293
1294     } elsif ( $self->api_name =~ /bindery/ ) {
1295         $perm = 'MARK_ITEM_BINDERY';
1296         $stat = OILS_COPY_STATUS_BINDERY;
1297     } elsif ( $self->api_name =~ /on_order/ ) {
1298         $perm = 'MARK_ITEM_ON_ORDER';
1299         $stat = OILS_COPY_STATUS_ON_ORDER;
1300     } elsif ( $self->api_name =~ /ill/ ) {
1301         $perm = 'MARK_ITEM_ILL';
1302         $stat = OILS_COPY_STATUS_ILL;
1303     } elsif ( $self->api_name =~ /cataloging/ ) {
1304         $perm = 'MARK_ITEM_CATALOGING';
1305         $stat = OILS_COPY_STATUS_CATALOGING;
1306     } elsif ( $self->api_name =~ /reserves/ ) {
1307         $perm = 'MARK_ITEM_RESERVES';
1308         $stat = OILS_COPY_STATUS_RESERVES;
1309     } elsif ( $self->api_name =~ /discard/ ) {
1310         $perm = 'MARK_ITEM_DISCARD';
1311         $stat = OILS_COPY_STATUS_DISCARD;
1312     }
1313
1314     # caller may proceed if either perm is allowed
1315     return $e->die_event unless $e->allowed([$perm, 'UPDATE_COPY'], $owning_lib);
1316
1317     $copy->status($stat);
1318     $copy->edit_date('now');
1319     $copy->editor($e->requestor->id);
1320
1321     $e->update_asset_copy($copy) or return $e->die_event;
1322
1323     my $holds = $e->search_action_hold_request(
1324         { 
1325             current_copy => $copy->id,
1326             fulfillment_time => undef,
1327             cancel_time => undef,
1328         }
1329     );
1330
1331     $e->commit;
1332
1333     if( $self->api_name =~ /damaged/ ) {
1334         # now that we've committed the changes, create related A/T events
1335         my $ses = OpenSRF::AppSession->create('open-ils.trigger');
1336         $ses->request('open-ils.trigger.event.autocreate', 'damaged', $copy, $owning_lib);
1337     }
1338
1339     $logger->debug("resetting holds that target the marked copy");
1340     OpenILS::Application::Circ::Holds->_reset_hold($e->requestor, $_) for @$holds;
1341
1342     return 1;
1343 }
1344
1345 sub handle_mark_damaged {
1346     my($e, $copy, $owning_lib, $args) = @_;
1347
1348     my $apply = $args->{apply_fines} || '';
1349     return undef if $apply eq 'noapply';
1350
1351     my $new_amount = $args->{override_amount};
1352     my $new_btype = $args->{override_btype};
1353     my $new_note = $args->{override_note};
1354
1355     # grab the last circulation
1356     my $circ = $e->search_action_circulation([
1357         {   target_copy => $copy->id}, 
1358         {   limit => 1, 
1359             order_by => {circ => "xact_start DESC"},
1360             flesh => 2,
1361             flesh_fields => {circ => ['target_copy', 'usr'], au => ['card']}
1362         }
1363     ])->[0];
1364
1365     return undef unless $circ;
1366
1367     my $charge_price = $U->ou_ancestor_setting_value(
1368         $owning_lib, 'circ.charge_on_damaged', $e);
1369
1370     my $proc_fee = $U->ou_ancestor_setting_value(
1371         $owning_lib, 'circ.damaged_item_processing_fee', $e) || 0;
1372
1373     my $void_overdue = $U->ou_ancestor_setting_value(
1374         $owning_lib, 'circ.damaged.void_ovedue', $e) || 0;
1375
1376     return undef unless $charge_price or $proc_fee;
1377
1378     my $copy_price = ($charge_price) ? $U->get_copy_price($e, $copy) : 0;
1379     my $total = $copy_price + $proc_fee;
1380
1381     if($apply) {
1382         
1383         if($new_amount and $new_btype) {
1384
1385             # Allow staff to override the amount to charge for a damaged item
1386             # Consider the case where the item is only partially damaged
1387             # This value is meant to take the place of the item price and
1388             # optional processing fee.
1389
1390             my $evt = OpenILS::Application::Circ::CircCommon->create_bill(
1391                 $e, $new_amount, $new_btype, 'Damaged Item Override', $circ->id, $new_note);
1392             return $evt if $evt;
1393
1394         } else {
1395
1396             if($charge_price and $copy_price) {
1397                 my $evt = OpenILS::Application::Circ::CircCommon->create_bill(
1398                     $e, $copy_price, 7, 'Damaged Item', $circ->id);
1399                 return $evt if $evt;
1400             }
1401
1402             if($proc_fee) {
1403                 my $evt = OpenILS::Application::Circ::CircCommon->create_bill(
1404                     $e, $proc_fee, 8, 'Damaged Item Processing Fee', $circ->id);
1405                 return $evt if $evt;
1406             }
1407         }
1408
1409         # the assumption is that you would not void the overdues unless you 
1410         # were also charging for the item and/or applying a processing fee
1411         if($void_overdue) {
1412             my $evt = OpenILS::Application::Circ::CircCommon->void_or_zero_overdues($e, $circ, {note => 'System: OVERDUE REVERSED FOR DAMAGE CHARGE'});
1413             return $evt if $evt;
1414         }
1415
1416         my $evt = OpenILS::Application::Circ::CircCommon->reopen_xact($e, $circ->id);
1417         return $evt if $evt;
1418
1419         my $ses = OpenSRF::AppSession->create('open-ils.trigger');
1420         $ses->request('open-ils.trigger.event.autocreate', 'checkout.damaged', $circ, $circ->circ_lib);
1421
1422         my $evt2 = OpenILS::Utils::Penalty->calculate_penalties($e, $circ->usr->id, $e->requestor->ws_ou);
1423         return $evt2 if $evt2;
1424
1425         return undef;
1426
1427     } else {
1428         return OpenILS::Event->new('DAMAGE_CHARGE', 
1429             payload => {
1430                 circ => $circ,
1431                 charge => $total
1432             }
1433         );
1434     }
1435 }
1436
1437
1438
1439 # ----------------------------------------------------------------------
1440 __PACKAGE__->register_method(
1441     method => 'mark_item_missing_pieces',
1442     api_name => 'open-ils.circ.mark_item_missing_pieces',
1443     signature   => q/
1444         Changes the status of a copy to "damaged" or to a custom status based on the 
1445         circ.missing_pieces.copy_status org unit setting. Requires MARK_ITEM_MISSING_PIECES
1446         permission.
1447         @param authtoken The login session key
1448         @param copy_id The ID of the copy to mark as damaged
1449         @return Success event with circ and copy objects in the payload, or error Event otherwise.
1450         /
1451 );
1452
1453 sub mark_item_missing_pieces {
1454     my( $self, $conn, $auth, $copy_id, $args ) = @_;
1455     ### FIXME: We're starting a transaction here, but we're doing a lot of things outside of the transaction
1456     ### FIXME: Even better, we're going to use two transactions, the first to affect pertinent holds before checkout can
1457
1458     my $e2 = new_editor(authtoken=>$auth, xact =>1);
1459     return $e2->die_event unless $e2->checkauth;
1460     $args ||= {};
1461
1462     my $copy = $e2->retrieve_asset_copy([
1463         $copy_id,
1464         {flesh => 1, flesh_fields => {'acp' => ['call_number']}}])
1465             or return $e2->die_event;
1466
1467     my $owning_lib = 
1468         ($copy->call_number->id == OILS_PRECAT_CALL_NUMBER) ? 
1469             $copy->circ_lib : $copy->call_number->owning_lib;
1470
1471     return $e2->die_event unless $e2->allowed('MARK_ITEM_MISSING_PIECES', $owning_lib);
1472
1473     #### grab the last circulation
1474     my $circ = $e2->search_action_circulation([
1475         {   target_copy => $copy->id}, 
1476         {   limit => 1, 
1477             order_by => {circ => "xact_start DESC"}
1478         }
1479     ])->[0];
1480
1481     if (!$circ) {
1482         $logger->info('open-ils.circ.mark_item_missing_pieces: no previous checkout');
1483         $e2->rollback;
1484         return OpenILS::Event->new('ACTION_CIRCULATION_NOT_FOUND',{'copy'=>$copy});
1485     }
1486
1487     my $holds = $e2->search_action_hold_request(
1488         { 
1489             current_copy => $copy->id,
1490             fulfillment_time => undef,
1491             cancel_time => undef,
1492         }
1493     );
1494
1495     $logger->debug("resetting holds that target the marked copy");
1496     OpenILS::Application::Circ::Holds->_reset_hold($e2->requestor, $_) for @$holds;
1497
1498     
1499     if (! $e2->commit) {
1500         return $e2->die_event;
1501     }
1502
1503     my $e = new_editor(authtoken=>$auth, xact =>1);
1504     return $e->die_event unless $e->checkauth;
1505
1506     if (! $circ->checkin_time) { # if circ active, attempt renew
1507         my ($res) = $self->method_lookup('open-ils.circ.renew')->run($e->authtoken,{'copy_id'=>$circ->target_copy});
1508         if (ref $res ne 'ARRAY') { $res = [ $res ]; }
1509         if ( $res->[0]->{textcode} eq 'SUCCESS' ) {
1510             $circ = $res->[0]->{payload}{'circ'};
1511             $circ->target_copy( $copy->id );
1512             $logger->info('open-ils.circ.mark_item_missing_pieces: successful renewal');
1513         } else {
1514             $logger->info('open-ils.circ.mark_item_missing_pieces: non-successful renewal');
1515         }
1516     } else {
1517
1518         my $co_params = {
1519             'copy_id'=>$circ->target_copy,
1520             'patron_id'=>$circ->usr,
1521             'skip_deposit_fee'=>1,
1522             'skip_rental_fee'=>1
1523         };
1524
1525         if ($U->ou_ancestor_setting_value($e->requestor->ws_ou, 'circ.block_renews_for_holds')) {
1526
1527             my ($hold, undef, $retarget) = $holdcode->find_nearest_permitted_hold(
1528                 $e, $copy, $e->requestor, 1 );
1529
1530             if ($hold) { # needed for hold? then due now
1531
1532                 $logger->info('open-ils.circ.mark_item_missing_pieces: item needed for hold, shortening due date');
1533                 my $due_date = DateTime->now(time_zone => 'local');
1534                 $co_params->{'due_date'} = cleanse_ISO8601( $due_date->strftime('%FT%T%z') );
1535             } else {
1536                 $logger->info('open-ils.circ.mark_item_missing_pieces: item not needed for hold');
1537             }
1538         }
1539
1540         my ($res) = $self->method_lookup('open-ils.circ.checkout.full.override')->run($e->authtoken,$co_params,{ all => 1 });
1541         if (ref $res ne 'ARRAY') { $res = [ $res ]; }
1542         if ( $res->[0]->{textcode} eq 'SUCCESS' ) {
1543             $logger->info('open-ils.circ.mark_item_missing_pieces: successful checkout');
1544             $circ = $res->[0]->{payload}{'circ'};
1545         } else {
1546             $logger->info('open-ils.circ.mark_item_missing_pieces: non-successful checkout');
1547             $e->rollback;
1548             return $res;
1549         }
1550     }
1551
1552     ### Update the item status
1553
1554     my $custom_stat = $U->ou_ancestor_setting_value(
1555         $owning_lib, 'circ.missing_pieces.copy_status', $e);
1556     my $stat = $custom_stat || OILS_COPY_STATUS_DAMAGED;
1557
1558     my $ses = OpenSRF::AppSession->create('open-ils.trigger');
1559     $ses->request('open-ils.trigger.event.autocreate', 'missing_pieces', $copy, $owning_lib);
1560
1561     $copy->status($stat);
1562     $copy->edit_date('now');
1563     $copy->editor($e->requestor->id);
1564
1565     $e->update_asset_copy($copy) or return $e->die_event;
1566
1567     if ($e->commit) {
1568
1569         my $ses = OpenSRF::AppSession->create('open-ils.trigger');
1570         $ses->request('open-ils.trigger.event.autocreate', 'circ.missing_pieces', $circ, $circ->circ_lib);
1571
1572         return OpenILS::Event->new('SUCCESS',
1573             payload => {
1574                 circ => $circ,
1575                 copy => $copy,
1576                 slip => $U->fire_object_event(undef, 'circ.format.missing_pieces.slip.print', $circ, $circ->circ_lib),
1577                 letter => $U->fire_object_event(undef, 'circ.format.missing_pieces.letter.print', $circ, $circ->circ_lib)
1578             }
1579         ); 
1580
1581     } else {
1582         return $e->die_event;
1583     }
1584 }
1585
1586
1587
1588
1589
1590 # ----------------------------------------------------------------------
1591 __PACKAGE__->register_method(
1592     method => 'magic_fetch',
1593     api_name => 'open-ils.agent.fetch'
1594 );
1595
1596 my @FETCH_ALLOWED = qw/ aou aout acp acn bre /;
1597
1598 sub magic_fetch {
1599     my( $self, $conn, $auth, $args ) = @_;
1600     my $e = new_editor( authtoken => $auth );
1601     return $e->event unless $e->checkauth;
1602
1603     my $hint = $$args{hint};
1604     my $id  = $$args{id};
1605
1606     # Is the call allowed to fetch this type of object?
1607     return undef unless grep { $_ eq $hint } @FETCH_ALLOWED;
1608
1609     # Find the class the implements the given hint
1610     my ($class) = grep { 
1611         $Fieldmapper::fieldmap->{$_}{hint} eq $hint } Fieldmapper->classes;
1612
1613     $class =~ s/Fieldmapper:://og;
1614     $class =~ s/::/_/og;
1615     my $method = "retrieve_$class";
1616
1617     my $obj = $e->$method($id) or return $e->event;
1618     return $obj;
1619 }
1620 # ----------------------------------------------------------------------
1621
1622
1623 __PACKAGE__->register_method(
1624     method  => "fleshed_circ_retrieve",
1625     authoritative => 1,
1626     api_name    => "open-ils.circ.fleshed.retrieve",);
1627
1628 sub fleshed_circ_retrieve {
1629     my( $self, $client, $id ) = @_;
1630     my $e = new_editor();
1631     my $circ = $e->retrieve_action_circulation(
1632         [
1633             $id,
1634             { 
1635                 flesh               => 4,
1636                 flesh_fields    => { 
1637                     circ => [ qw/ target_copy / ],
1638                     acp => [ qw/ location status stat_cat_entry_copy_maps notes age_protect call_number parts / ],
1639                     ascecm => [ qw/ stat_cat stat_cat_entry / ],
1640                     acn => [ qw/ record / ],
1641                 }
1642             }
1643         ]
1644     ) or return $e->event;
1645     
1646     my $copy = $circ->target_copy;
1647     my $vol = $copy->call_number;
1648     my $rec = $circ->target_copy->call_number->record;
1649
1650     $vol->record($rec->id);
1651     $copy->call_number($vol->id);
1652     $circ->target_copy($copy->id);
1653
1654     my $mvr;
1655
1656     if( $rec->id == OILS_PRECAT_RECORD ) {
1657         $rec = undef;
1658         $vol = undef;
1659     } else { 
1660         $mvr = $U->record_to_mvr($rec);
1661         $rec->marc(''); # drop the bulky marc data
1662     }
1663
1664     return {
1665         circ => $circ,
1666         copy => $copy,
1667         volume => $vol,
1668         record => $rec,
1669         mvr => $mvr,
1670     };
1671 }
1672
1673
1674
1675 __PACKAGE__->register_method(
1676     method  => "test_batch_circ_events",
1677     api_name    => "open-ils.circ.trigger_event_by_def_and_barcode.fire"
1678 );
1679
1680 #  method for testing the behavior of a given event definition
1681 sub test_batch_circ_events {
1682     my($self, $conn, $auth, $event_def, $barcode) = @_;
1683
1684     my $e = new_editor(authtoken => $auth);
1685     return $e->event unless $e->checkauth;
1686     return $e->event unless $e->allowed('VIEW_CIRCULATIONS');
1687
1688     my $copy = $e->search_asset_copy({barcode => $barcode, deleted => 'f'})->[0]
1689         or return $e->event;
1690
1691     my $circ = $e->search_action_circulation(
1692         {target_copy => $copy->id, checkin_time => undef})->[0]
1693         or return $e->event;
1694         
1695     return undef unless $circ;
1696
1697     return $U->fire_object_event($event_def, undef, $circ, $e->requestor->ws_ou)
1698 }
1699
1700
1701 __PACKAGE__->register_method(
1702     method  => "fire_circ_events", 
1703     api_name    => "open-ils.circ.fire_circ_trigger_events",
1704     signature => q/
1705         General event def runner for circ objects.  If no event def ID
1706         is provided, the hook will be used to find the best event_def
1707         match based on the context org unit
1708     /
1709 );
1710
1711 __PACKAGE__->register_method(
1712     method  => "fire_circ_events", 
1713     api_name    => "open-ils.circ.fire_hold_trigger_events",
1714     signature => q/
1715         General event def runner for hold objects.  If no event def ID
1716         is provided, the hook will be used to find the best event_def
1717         match based on the context org unit
1718     /
1719 );
1720
1721 __PACKAGE__->register_method(
1722     method  => "fire_circ_events", 
1723     api_name    => "open-ils.circ.fire_user_trigger_events",
1724     signature => q/
1725         General event def runner for user objects.  If no event def ID
1726         is provided, the hook will be used to find the best event_def
1727         match based on the context org unit
1728     /
1729 );
1730
1731
1732 sub fire_circ_events {
1733     my($self, $conn, $auth, $org_id, $event_def, $hook, $granularity, $target_ids, $user_data) = @_;
1734
1735     my $e = new_editor(authtoken => $auth, xact => 1);
1736     return $e->event unless $e->checkauth;
1737
1738     my $targets;
1739
1740     if($self->api_name =~ /hold/) {
1741         return $e->event unless $e->allowed('VIEW_HOLD', $org_id);
1742         $targets = $e->batch_retrieve_action_hold_request($target_ids);
1743     } elsif($self->api_name =~ /user/) {
1744         return $e->event unless $e->allowed('VIEW_USER', $org_id);
1745         $targets = $e->batch_retrieve_actor_user($target_ids);
1746     } else {
1747         return $e->event unless $e->allowed('VIEW_CIRCULATIONS', $org_id);
1748         $targets = $e->batch_retrieve_action_circulation($target_ids);
1749     }
1750     $e->rollback; # FIXME using transaction because of pgpool/slony setups, but not
1751                   # simply making this method authoritative because of weirdness
1752                   # with transaction handling in A/T code that causes rollback
1753                   # failure down the line if handling many targets
1754
1755     return undef unless @$targets;
1756     return $U->fire_object_event($event_def, $hook, $targets, $org_id, $granularity, $user_data);
1757 }
1758
1759 __PACKAGE__->register_method(
1760     method  => "user_payments_list",
1761     api_name    => "open-ils.circ.user_payments.filtered.batch",
1762     stream => 1,
1763     signature => {
1764         desc => q/Returns a fleshed, date-limited set of all payments a user
1765                 has made.  By default, ordered by payment date.  Optionally
1766                 ordered by other columns in the top-level "mp" object/,
1767         params => [
1768             {desc => 'Authentication token', type => 'string'},
1769             {desc => 'User ID', type => 'number'},
1770             {desc => 'Order by column(s), optional.  Array of "mp" class columns', type => 'array'}
1771         ],
1772         return => {desc => q/List of "mp" objects, fleshed with the billable transaction 
1773             and the related fully-realized payment object (e.g money.cash_payment)/}
1774     }
1775 );
1776
1777 sub user_payments_list {
1778     my($self, $conn, $auth, $user_id, $start_date, $end_date, $order_by) = @_;
1779
1780     my $e = new_editor(authtoken => $auth);
1781     return $e->event unless $e->checkauth;
1782
1783     my $user = $e->retrieve_actor_user($user_id) or return $e->event;
1784     return $e->event unless $e->allowed('VIEW_CIRCULATIONS', $user->home_ou);
1785
1786     $order_by ||= ['payment_ts'];
1787
1788     # all payments by user, between start_date and end_date
1789     my $payments = $e->json_query({
1790         select => {mp => ['id']}, 
1791         from => {
1792             mp => {
1793                 mbt => {
1794                     fkey => 'xact', field => 'id'}
1795             }
1796         }, 
1797         where => {
1798             '+mbt' => {usr => $user_id}, 
1799             '+mp' => {payment_ts => {between => [$start_date, $end_date]}}
1800         },
1801         order_by => {mp => $order_by}
1802     });
1803
1804     for my $payment_id (@$payments) {
1805         my $payment = $e->retrieve_money_payment([
1806             $payment_id->{id}, 
1807             {   
1808                 flesh => 2,
1809                 flesh_fields => {
1810                     mp => [
1811                         'xact',
1812                         'cash_payment',
1813                         'credit_card_payment',
1814                         'credit_payment',
1815                         'check_payment',
1816                         'work_payment',
1817                         'forgive_payment',
1818                         'goods_payment'
1819                     ],
1820                     mbt => [
1821                         'circulation', 
1822                         'grocery',
1823                         'reservation'
1824                     ]
1825                 }
1826             }
1827         ]);
1828         $conn->respond($payment);
1829     }
1830
1831     return undef;
1832 }
1833
1834
1835 __PACKAGE__->register_method(
1836     method  => "retrieve_circ_chain",
1837     api_name    => "open-ils.circ.renewal_chain.retrieve_by_circ",
1838     stream => 1,
1839     signature => {
1840         desc => q/Given a circulation, this returns all circulation objects
1841                 that are part of the same chain of renewals./,
1842         params => [
1843             {desc => 'Authentication token', type => 'string'},
1844             {desc => 'Circ ID', type => 'number'},
1845         ],
1846         return => {desc => q/List of circ objects, orderd by oldest circ first/}
1847     }
1848 );
1849
1850 __PACKAGE__->register_method(
1851     method  => "retrieve_circ_chain",
1852     api_name    => "open-ils.circ.renewal_chain.retrieve_by_circ.summary",
1853     signature => {
1854         desc => q/Given a circulation, this returns a summary of the circulation objects
1855                 that are part of the same chain of renewals./,
1856         params => [
1857             {desc => 'Authentication token', type => 'string'},
1858             {desc => 'Circ ID', type => 'number'},
1859         ],
1860         return => {desc => q/Circulation Chain Summary/}
1861     }
1862 );
1863
1864 sub retrieve_circ_chain {
1865     my($self, $conn, $auth, $circ_id) = @_;
1866
1867     my $e = new_editor(authtoken => $auth);
1868     return $e->event unless $e->checkauth;
1869     return $e->event unless $e->allowed('VIEW_CIRCULATIONS');
1870
1871     if($self->api_name =~ /summary/) {
1872         return $U->create_circ_chain_summary($e, $circ_id);
1873
1874     } else {
1875
1876         my $chain = $e->json_query({from => ['action.all_circ_chain', $circ_id]});
1877
1878         for my $circ_info (@$chain) {
1879             my $circ = Fieldmapper::action::all_circulation->new;
1880             $circ->$_($circ_info->{$_}) for keys %$circ_info;
1881             $conn->respond($circ);
1882         }
1883     }
1884
1885     return undef;
1886 }
1887
1888 __PACKAGE__->register_method(
1889     method  => "retrieve_prev_circ_chain",
1890     api_name    => "open-ils.circ.prev_renewal_chain.retrieve_by_circ",
1891     stream => 1,
1892     signature => {
1893         desc => q/Given a circulation, this returns all circulation objects
1894                 that are part of the previous chain of renewals./,
1895         params => [
1896             {desc => 'Authentication token', type => 'string'},
1897             {desc => 'Circ ID', type => 'number'},
1898         ],
1899         return => {desc => q/List of circ objects, orderd by oldest circ first/}
1900     }
1901 );
1902
1903 __PACKAGE__->register_method(
1904     method  => "retrieve_prev_circ_chain",
1905     api_name    => "open-ils.circ.prev_renewal_chain.retrieve_by_circ.summary",
1906     signature => {
1907         desc => q/Given a circulation, this returns a summary of the circulation objects
1908                 that are part of the previous chain of renewals./,
1909         params => [
1910             {desc => 'Authentication token', type => 'string'},
1911             {desc => 'Circ ID', type => 'number'},
1912         ],
1913         return => {desc => q/Object containing Circulation Chain Summary and User Id/}
1914     }
1915 );
1916
1917 sub retrieve_prev_circ_chain {
1918     my($self, $conn, $auth, $circ_id) = @_;
1919
1920     my $e = new_editor(authtoken => $auth);
1921     return $e->event unless $e->checkauth;
1922     return $e->event unless $e->allowed('VIEW_CIRCULATIONS');
1923
1924     my $first_circ = 
1925         $e->json_query({from => ['action.all_circ_chain', $circ_id]})->[0];
1926
1927     my $prev_circ = $e->search_action_all_circulation([
1928         {   target_copy => $first_circ->{target_copy},
1929             xact_start => {'<' => $first_circ->{xact_start}}
1930         }, {   
1931             flesh => 1,
1932             flesh_fields => {
1933                 combcirc => [
1934                     'active_circ',
1935                     'aged_circ'
1936                 ]
1937             },
1938             order_by => { combcirc => 'xact_start desc' },
1939             limit => 1 
1940         }
1941     ])->[0];
1942
1943     return undef unless $prev_circ;
1944
1945     my $chain_usr = $prev_circ->usr; # note: may be undef
1946
1947     if ($self->api_name =~ /summary/) {
1948         my $sum = $e->json_query({
1949             from => [
1950                 'action.summarize_all_circ_chain', 
1951                 $prev_circ->id
1952             ]
1953         })->[0];
1954
1955         my $summary = Fieldmapper::action::circ_chain_summary->new;
1956         $summary->$_($sum->{$_}) for keys %$sum;
1957
1958         return {summary => $summary, usr => $chain_usr};
1959     }
1960
1961
1962     my $chain = $e->json_query(
1963         {from => ['action.all_circ_chain', $prev_circ->id]});
1964
1965     for my $circ_info (@$chain) {
1966         my $circ = Fieldmapper::action::all_circulation->new;
1967         $circ->$_($circ_info->{$_}) for keys %$circ_info;
1968         $conn->respond($circ);
1969     }
1970
1971     return undef;
1972 }
1973
1974
1975 __PACKAGE__->register_method(
1976     method  => "get_copy_due_date",
1977     api_name    => "open-ils.circ.copy.due_date.retrieve",
1978     signature => {
1979         desc => q/
1980             Given a copy ID, returns the due date for the copy if it's 
1981             currently circulating.  Otherwise, returns null.  Note, this is a public 
1982             method requiring no authentication.  Only the due date is exposed.
1983             /,
1984         params => [
1985             {desc => 'Copy ID', type => 'number'}
1986         ],
1987         return => {desc => q/
1988             Due date (ISO date stamp) if the copy is circulating, null otherwise.
1989         /}
1990     }
1991 );
1992
1993 sub get_copy_due_date {
1994     my($self, $conn, $copy_id) = @_;
1995     my $e = new_editor();
1996
1997     my $circ = $e->json_query({
1998         select => {circ => ['due_date']},
1999         from => 'circ',
2000         where => {
2001             target_copy => $copy_id,
2002             checkin_time => undef,
2003             '-or' => [
2004                 {stop_fines => ["MAXFINES","LONGOVERDUE"]},
2005                 {stop_fines => undef}
2006             ],
2007         },
2008         limit => 1
2009     })->[0] or return undef;
2010
2011     return $circ->{due_date};
2012 }
2013
2014
2015
2016
2017
2018 # {"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}}
2019
2020
2021 1;