LP#1386347: Clear hold-copy-map efficiently
[Evergreen.git] / Open-ILS / src / perlmods / lib / OpenILS / Application / Circ / Circulate.pm
1 package OpenILS::Application::Circ::Circulate;
2 use strict; use warnings;
3 use base 'OpenILS::Application';
4 use OpenSRF::EX qw(:try);
5 use OpenSRF::AppSession;
6 use OpenSRF::Utils::SettingsClient;
7 use OpenSRF::Utils::Logger qw(:logger);
8 use OpenILS::Const qw/:const/;
9 use OpenILS::Application::AppUtils;
10 use DateTime;
11 my $U = "OpenILS::Application::AppUtils";
12
13 my %scripts;
14 my $script_libs;
15 my $legacy_script_support = 0;
16 my $booking_status;
17 my $opac_renewal_use_circ_lib;
18 my $desk_renewal_use_circ_lib;
19
20 sub determine_booking_status {
21     unless (defined $booking_status) {
22         my $ses = create OpenSRF::AppSession("router");
23         $booking_status = grep {$_ eq "open-ils.booking"} @{
24             $ses->request("opensrf.router.info.class.list")->gather(1)
25         };
26         $ses->disconnect;
27         $logger->info("booking status: " . ($booking_status ? "on" : "off"));
28     }
29
30     return $booking_status;
31 }
32
33
34 my $MK_ENV_FLESH = { 
35     flesh => 2, 
36     flesh_fields => {acp => ['call_number','parts','floating'], acn => ['record']}
37 };
38
39 sub initialize {
40
41     my $self = shift;
42     my $conf = OpenSRF::Utils::SettingsClient->new;
43     my @pfx2 = ( "apps", "open-ils.circ","app_settings" );
44
45     $legacy_script_support = $conf->config_value(@pfx2, 'legacy_script_support');
46     $legacy_script_support = ($legacy_script_support and $legacy_script_support =~ /true/i);
47
48     my $lb  = $conf->config_value(  @pfx2, 'script_path' );
49     $lb = [ $lb ] unless ref($lb);
50     $script_libs = $lb;
51
52     return unless $legacy_script_support;
53
54     my @pfx = ( @pfx2, "scripts" );
55     my $p   = $conf->config_value(  @pfx, 'circ_permit_patron' );
56     my $c   = $conf->config_value(  @pfx, 'circ_permit_copy' );
57     my $d   = $conf->config_value(  @pfx, 'circ_duration' );
58     my $f   = $conf->config_value(  @pfx, 'circ_recurring_fines' );
59     my $m   = $conf->config_value(  @pfx, 'circ_max_fines' );
60     my $pr  = $conf->config_value(  @pfx, 'circ_permit_renew' );
61
62     $logger->error( "Missing circ script(s)" ) 
63         unless( $p and $c and $d and $f and $m and $pr );
64
65     $scripts{circ_permit_patron}   = $p;
66     $scripts{circ_permit_copy}     = $c;
67     $scripts{circ_duration}        = $d;
68     $scripts{circ_recurring_fines} = $f;
69     $scripts{circ_max_fines}       = $m;
70     $scripts{circ_permit_renew}    = $pr;
71
72     $logger->debug(
73         "circulator: Loaded rules scripts for circ: " .
74         "circ permit patron = $p, ".
75         "circ permit copy = $c, ".
76         "circ duration = $d, ".
77         "circ recurring fines = $f, " .
78         "circ max fines = $m, ".
79         "circ renew permit = $pr.  ".
80         "lib paths = @$lb. ".
81         "legacy script support = ". ($legacy_script_support) ? 'yes' : 'no'
82         );
83 }
84
85 __PACKAGE__->register_method(
86     method  => "run_method",
87     api_name    => "open-ils.circ.checkout.permit",
88     notes       => q/
89         Determines if the given checkout can occur
90         @param authtoken The login session key
91         @param params A trailing hash of named params including 
92             barcode : The copy barcode, 
93             patron : The patron the checkout is occurring for, 
94             renew : true or false - whether or not this is a renewal
95         @return The event that occurred during the permit check.  
96     /);
97
98
99 __PACKAGE__->register_method (
100     method      => 'run_method',
101     api_name        => 'open-ils.circ.checkout.permit.override',
102     signature   => q/@see open-ils.circ.checkout.permit/,
103 );
104
105
106 __PACKAGE__->register_method(
107     method  => "run_method",
108     api_name    => "open-ils.circ.checkout",
109     notes => q/
110         Checks out an item
111         @param authtoken The login session key
112         @param params A named hash of params including:
113             copy            The copy object
114             barcode     If no copy is provided, the copy is retrieved via barcode
115             copyid      If no copy or barcode is provide, the copy id will be use
116             patron      The patron's id
117             noncat      True if this is a circulation for a non-cataloted item
118             noncat_type The non-cataloged type id
119             noncat_circ_lib The location for the noncat circ.  
120             precat      The item has yet to be cataloged
121             dummy_title The temporary title of the pre-cataloded item
122             dummy_author The temporary authr of the pre-cataloded item
123                 Default is the home org of the staff member
124         @return The SUCCESS event on success, any other event depending on the error
125     /);
126
127 __PACKAGE__->register_method(
128     method  => "run_method",
129     api_name    => "open-ils.circ.checkin",
130     argc        => 2,
131     signature   => q/
132         Generic super-method for handling all copies
133         @param authtoken The login session key
134         @param params Hash of named parameters including:
135             barcode - The copy barcode
136             force   - If true, copies in bad statuses will be checked in and give good statuses
137             noop    - don't capture holds or put items into transit
138             void_overdues - void all overdues for the circulation (aka amnesty)
139             ...
140     /
141 );
142
143 __PACKAGE__->register_method(
144     method    => "run_method",
145     api_name  => "open-ils.circ.checkin.override",
146     signature => q/@see open-ils.circ.checkin/
147 );
148
149 __PACKAGE__->register_method(
150     method    => "run_method",
151     api_name  => "open-ils.circ.renew.override",
152     signature => q/@see open-ils.circ.renew/,
153 );
154
155
156 __PACKAGE__->register_method(
157     method  => "run_method",
158     api_name    => "open-ils.circ.renew",
159     notes       => <<"    NOTES");
160     PARAMS( authtoken, circ => circ_id );
161     open-ils.circ.renew(login_session, circ_object);
162     Renews the provided circulation.  login_session is the requestor of the
163     renewal and if the logged in user is not the same as circ->usr, then
164     the logged in user must have RENEW_CIRC permissions.
165     NOTES
166
167 __PACKAGE__->register_method(
168     method   => "run_method",
169     api_name => "open-ils.circ.checkout.full"
170 );
171 __PACKAGE__->register_method(
172     method   => "run_method",
173     api_name => "open-ils.circ.checkout.full.override"
174 );
175 __PACKAGE__->register_method(
176     method   => "run_method",
177     api_name => "open-ils.circ.reservation.pickup"
178 );
179 __PACKAGE__->register_method(
180     method   => "run_method",
181     api_name => "open-ils.circ.reservation.return"
182 );
183 __PACKAGE__->register_method(
184     method   => "run_method",
185     api_name => "open-ils.circ.reservation.return.override"
186 );
187 __PACKAGE__->register_method(
188     method   => "run_method",
189     api_name => "open-ils.circ.checkout.inspect",
190     desc     => q/Returns the circ matrix test result and, on success, the rule set and matrix test object/
191 );
192
193
194 sub run_method {
195     my( $self, $conn, $auth, $args ) = @_;
196     translate_legacy_args($args);
197     $args->{override_args} = { all => 1 } unless defined $args->{override_args};
198     my $api = $self->api_name;
199
200     my $circulator = 
201         OpenILS::Application::Circ::Circulator->new($auth, %$args);
202
203     return circ_events($circulator) if $circulator->bail_out;
204
205     $circulator->use_booking(determine_booking_status());
206
207     # --------------------------------------------------------------------------
208     # First, check for a booking transit, as the barcode may not be a copy
209     # barcode, but a resource barcode, and nothing else in here will work
210     # --------------------------------------------------------------------------
211
212     if ($circulator->use_booking && (my $bc = $circulator->copy_barcode) && $api !~ /checkout|inspect/) { # do we have a barcode?
213         my $resources = $circulator->editor->search_booking_resource( { barcode => $bc } ); # any resources by this barcode?
214         if (@$resources) { # yes!
215
216             my $res_id_list = [ map { $_->id } @$resources ];
217             my $transit = $circulator->editor->search_action_reservation_transit_copy(
218                 [
219                     { target_copy => $res_id_list, dest => $circulator->circ_lib, dest_recv_time => undef },
220                     { order_by => { artc => 'source_send_time' }, limit => 1 }
221                 ]
222             )->[0]; # Any transit for this barcode?
223
224             if ($transit) { # yes! unwrap it.
225
226                 my $reservation = $circulator->editor->retrieve_booking_reservation( $transit->reservation );
227                 my $res_type    = $circulator->editor->retrieve_booking_resource_type( $reservation->target_resource_type );
228
229                 my $success_event = new OpenILS::Event(
230                     "SUCCESS", "payload" => {"reservation" => $reservation}
231                 );
232                 if ($U->is_true($res_type->catalog_item)) { # is there a copy to be had here?
233                     if (my $copy = $circulator->editor->search_asset_copy([
234                         { barcode => $bc, deleted => 'f' }, $MK_ENV_FLESH
235                     ])->[0]) { # got a copy
236                         $copy->status( $transit->copy_status );
237                         $copy->editor($circulator->editor->requestor->id);
238                         $copy->edit_date('now');
239                         $circulator->editor->update_asset_copy($copy);
240                         $success_event->{"payload"}->{"record"} =
241                             $U->record_to_mvr($copy->call_number->record);
242                         $success_event->{"payload"}->{"volume"} = $copy->call_number;
243                         $copy->call_number($copy->call_number->id);
244                         $success_event->{"payload"}->{"copy"} = $copy;
245                     }
246                 }
247
248                 $transit->dest_recv_time('now');
249                 $circulator->editor->update_action_reservation_transit_copy( $transit );
250
251                 $circulator->editor->commit;
252                 # Formerly this branch just stopped here. Argh!
253                 $conn->respond_complete($success_event);
254                 return;
255             }
256         }
257     }
258             
259     
260
261     # --------------------------------------------------------------------------
262     # Go ahead and load the script runner to make sure we have all 
263     # of the objects we need
264     # --------------------------------------------------------------------------
265
266     if ($circulator->use_booking) {
267         $circulator->is_res_checkin($circulator->is_checkin(1))
268             if $api =~ /reservation.return/ or (
269                 $api =~ /checkin/ and $circulator->seems_like_reservation()
270             );
271
272         $circulator->is_res_checkout(1) if $api =~ /reservation.pickup/;
273     }
274
275     $circulator->is_renewal(1) if $api =~ /renew/;
276     $circulator->is_checkin(1) if $api =~ /checkin/;
277
278     $circulator->mk_env();
279     $circulator->noop(1) if $circulator->claims_never_checked_out;
280
281     if($legacy_script_support and not $circulator->is_checkin) {
282         $circulator->mk_script_runner();
283         $circulator->legacy_script_support(1);
284         $circulator->circ_permit_patron($scripts{circ_permit_patron});
285         $circulator->circ_permit_copy($scripts{circ_permit_copy});      
286         $circulator->circ_duration($scripts{circ_duration});             
287         $circulator->circ_permit_renew($scripts{circ_permit_renew});
288     }
289     return circ_events($circulator) if $circulator->bail_out;
290
291     
292     $circulator->override(1) if $api =~ /override/o;
293
294     if( $api =~ /checkout\.permit/ ) {
295         $circulator->do_permit();
296
297     } elsif( $api =~ /checkout.full/ ) {
298
299         # requesting a precat checkout implies that any required
300         # overrides have been performed.  Go ahead and re-override.
301         $circulator->skip_permit_key(1);
302         $circulator->override(1) if $circulator->request_precat;
303         $circulator->do_permit();
304         $circulator->is_checkout(1);
305         unless( $circulator->bail_out ) {
306             $circulator->events([]);
307             $circulator->do_checkout();
308         }
309
310     } elsif( $circulator->is_res_checkout ) {
311         $circulator->do_reservation_pickup();
312
313     } elsif( $api =~ /inspect/ ) {
314         my $data = $circulator->do_inspect();
315         $circulator->editor->rollback;
316         return $data;
317
318     } elsif( $api =~ /checkout/ ) {
319         $circulator->is_checkout(1);
320         $circulator->do_checkout();
321
322     } elsif( $circulator->is_res_checkin ) {
323         $circulator->do_reservation_return();
324         $circulator->do_checkin() if ($circulator->copy());
325     } elsif( $api =~ /checkin/ ) {
326         $circulator->do_checkin();
327
328     } elsif( $api =~ /renew/ ) {
329         $circulator->is_renewal(1);
330         $circulator->do_renew();
331     }
332
333     if( $circulator->bail_out ) {
334
335         my @ee;
336         # make sure no success event accidentally slip in
337         $circulator->events(
338             [ grep { $_->{textcode} ne 'SUCCESS' } @{$circulator->events} ]);
339
340         # Log the events
341         my @e = @{$circulator->events};
342         push( @ee, $_->{textcode} ) for @e;
343         $logger->info("circulator: bailing out with events: " . (join ", ", @ee));
344
345         $circulator->editor->rollback;
346
347     } else {
348
349         $circulator->editor->commit;
350
351         if ($circulator->generate_lost_overdue) {
352             # Generating additional overdue billings has to happen after the 
353             # main commit and before the final respond() so the caller can
354             # receive the latest transaction summary.
355             my $evt = $circulator->generate_lost_overdue_fines;
356             $circulator->bail_on_events($evt) if $evt;
357         }
358     }
359     
360     $conn->respond_complete(circ_events($circulator));
361
362     $circulator->script_runner->cleanup if $circulator->script_runner;
363
364     return undef if $circulator->bail_out;
365
366     $circulator->do_hold_notify($circulator->notify_hold)
367         if $circulator->notify_hold;
368     $circulator->retarget_holds if $circulator->retarget;
369     $circulator->append_reading_list;
370     $circulator->make_trigger_events;
371     
372     return undef;
373 }
374
375 sub circ_events {
376     my $circ = shift;
377     my @e = @{$circ->events};
378     # if we have multiple events, SUCCESS should not be one of them;
379     @e = grep { $_->{textcode} ne 'SUCCESS' } @e if @e > 1;
380     return (@e == 1) ? $e[0] : \@e;
381 }
382
383
384 sub translate_legacy_args {
385     my $args = shift;
386
387     if( $$args{barcode} ) {
388         $$args{copy_barcode} = $$args{barcode};
389         delete $$args{barcode};
390     }
391
392     if( $$args{copyid} ) {
393         $$args{copy_id} = $$args{copyid};
394         delete $$args{copyid};
395     }
396
397     if( $$args{patronid} ) {
398         $$args{patron_id} = $$args{patronid};
399         delete $$args{patronid};
400     }
401
402     if( $$args{patron} and !ref($$args{patron}) ) {
403         $$args{patron_id} = $$args{patron};
404         delete $$args{patron};
405     }
406
407
408     if( $$args{noncat} ) {
409         $$args{is_noncat} = $$args{noncat};
410         delete $$args{noncat};
411     }
412
413     if( $$args{precat} ) {
414         $$args{is_precat} = $$args{request_precat} = $$args{precat};
415         delete $$args{precat};
416     }
417 }
418
419
420
421 # --------------------------------------------------------------------------
422 # This package actually manages all of the circulation logic
423 # --------------------------------------------------------------------------
424 package OpenILS::Application::Circ::Circulator;
425 use strict; use warnings;
426 use vars q/$AUTOLOAD/;
427 use DateTime;
428 use OpenILS::Utils::Fieldmapper;
429 use OpenSRF::Utils::Cache;
430 use Digest::MD5 qw(md5_hex);
431 use DateTime::Format::ISO8601;
432 use OpenILS::Utils::PermitHold;
433 use OpenSRF::Utils qw/:datetime/;
434 use OpenSRF::Utils::SettingsClient;
435 use OpenILS::Application::Circ::Holds;
436 use OpenILS::Application::Circ::Transit;
437 use OpenSRF::Utils::Logger qw(:logger);
438 use OpenILS::Utils::CStoreEditor qw/:funcs/;
439 use OpenILS::Application::Circ::ScriptBuilder;
440 use OpenILS::Const qw/:const/;
441 use OpenILS::Utils::Penalty;
442 use OpenILS::Application::Circ::CircCommon;
443 use Time::Local;
444
445 my $holdcode    = "OpenILS::Application::Circ::Holds";
446 my $transcode   = "OpenILS::Application::Circ::Transit";
447 my %user_groups;
448
449 sub DESTROY { }
450
451
452 # --------------------------------------------------------------------------
453 # Add a pile of automagic getter/setter methods
454 # --------------------------------------------------------------------------
455 my @AUTOLOAD_FIELDS = qw/
456     notify_hold
457     remote_hold
458     backdate
459     reservation
460     copy
461     copy_id
462     copy_barcode
463     patron
464     patron_id
465     patron_barcode
466     script_runner
467     volume
468     title
469     is_renewal
470     is_checkout
471     is_res_checkout
472     is_precat
473     is_noncat
474     request_precat
475     is_checkin
476     is_res_checkin
477     noncat_type
478     editor
479     events
480     cache_handle
481     override
482     circ_permit_patron
483     circ_permit_copy
484     circ_duration
485     circ_recurring_fines
486     circ_max_fines
487     circ_permit_renew
488     circ
489     transit
490     hold
491     permit_key
492     noncat_circ_lib
493     noncat_count
494     checkout_time
495     dummy_title
496     dummy_author
497     dummy_isbn
498     circ_modifier
499     circ_lib
500     barcode
501     duration_level
502     recurring_fines_level
503     duration_rule
504     recurring_fines_rule
505     max_fine_rule
506     renewal_remaining
507     hard_due_date
508     due_date
509     fulfilled_holds
510     transit
511     checkin_changed
512     force
513     permit_override
514     pending_checkouts
515     cancelled_hold_transit
516     opac_renewal
517     phone_renewal
518     desk_renewal
519     sip_renewal
520     retarget
521     matrix_test_result
522     circ_matrix_matchpoint
523     circ_test_success
524     legacy_script_support
525     is_deposit
526     is_rental
527     deposit_billing
528     rental_billing
529     capture
530     noop
531     void_overdues
532     parent_circ
533     return_patron
534     claims_never_checked_out
535     skip_permit_key
536     skip_deposit_fee
537     skip_rental_fee
538     use_booking
539     generate_lost_overdue
540     clear_expired
541     retarget_mode
542     hold_as_transit
543     fake_hold_dest
544     limit_groups
545     override_args
546     checkout_is_for_hold
547     manual_float
548 /;
549
550
551 sub AUTOLOAD {
552     my $self = shift;
553     my $type = ref($self) or die "$self is not an object";
554     my $data = shift;
555     my $name = $AUTOLOAD;
556     $name =~ s/.*://o;   
557
558     unless (grep { $_ eq $name } @AUTOLOAD_FIELDS) {
559         $logger->error("circulator: $type: invalid autoload field: $name");
560         die "$type: invalid autoload field: $name\n" 
561     }
562
563     {
564         no strict 'refs';
565         *{"${type}::${name}"} = sub {
566             my $s = shift;
567             my $v = shift;
568             $s->{$name} = $v if defined $v;
569             return $s->{$name};
570         }
571     }
572     return $self->$name($data);
573 }
574
575
576 sub new {
577     my( $class, $auth, %args ) = @_;
578     $class = ref($class) || $class;
579     my $self = bless( {}, $class );
580
581     $self->events([]);
582     $self->editor(new_editor(xact => 1, authtoken => $auth));
583
584     unless( $self->editor->checkauth ) {
585         $self->bail_on_events($self->editor->event);
586         return $self;
587     }
588
589     $self->cache_handle(OpenSRF::Utils::Cache->new('global'));
590
591     $self->$_($args{$_}) for keys %args;
592
593     $self->circ_lib(
594         ($self->circ_lib) ? $self->circ_lib : $self->editor->requestor->ws_ou);
595
596     # if this is a renewal, default to desk_renewal
597     $self->desk_renewal(1) unless 
598         $self->opac_renewal or $self->phone_renewal or $self->sip_renewal;
599
600     $self->capture('') unless $self->capture;
601
602     unless(%user_groups) {
603         my $gps = $self->editor->retrieve_all_permission_grp_tree;
604         %user_groups = map { $_->id => $_ } @$gps;
605     }
606
607     return $self;
608 }
609
610
611 # --------------------------------------------------------------------------
612 # True if we should discontinue processing
613 # --------------------------------------------------------------------------
614 sub bail_out {
615     my( $self, $bool ) = @_;
616     if( defined $bool ) {
617         $logger->info("circulator: BAILING OUT") if $bool;
618         $self->{bail_out} = $bool;
619     }
620     return $self->{bail_out};
621 }
622
623
624 sub push_events {
625     my( $self, @evts ) = @_;
626     for my $e (@evts) {
627         next unless $e;
628         $e->{payload} = $self->copy if 
629               ($e->{textcode} eq 'COPY_NOT_AVAILABLE');
630
631         $logger->info("circulator: pushing event ".$e->{textcode});
632         push( @{$self->events}, $e ) unless
633             grep { $_->{textcode} eq $e->{textcode} } @{$self->events};
634     }
635 }
636
637 sub mk_permit_key {
638     my $self = shift;
639     return '' if $self->skip_permit_key;
640     my $key = md5_hex( time() . rand() . "$$" );
641     $self->cache_handle->put_cache( "oils_permit_key_$key", 1, 300 );
642     return $self->permit_key($key);
643 }
644
645 sub check_permit_key {
646     my $self = shift;
647     return 1 if $self->skip_permit_key;
648     my $key = $self->permit_key;
649     return 0 unless $key;
650     my $k = "oils_permit_key_$key";
651     my $one = $self->cache_handle->get_cache($k);
652     $self->cache_handle->delete_cache($k);
653     return ($one) ? 1 : 0;
654 }
655
656 sub seems_like_reservation {
657     my $self = shift;
658
659     # Some words about the following method:
660     # 1) It requires the VIEW_USER permission, but that's not an
661     # issue, right, since all staff should have that?
662     # 2) It returns only one reservation at a time, even if an item can be
663     # and is currently overbooked.  Hmmm....
664     my $booking_ses = create OpenSRF::AppSession("open-ils.booking");
665     my $result = $booking_ses->request(
666         "open-ils.booking.reservations.by_returnable_resource_barcode",
667         $self->editor->authtoken,
668         $self->copy_barcode
669     )->gather(1);
670     $booking_ses->disconnect;
671
672     return $self->bail_on_events($result) if defined $U->event_code($result);
673
674     if (@$result > 0) {
675         $self->reservation(shift @$result);
676         return 1;
677     } else {
678         return 0;
679     }
680
681 }
682
683 # save_trimmed_copy() used just to be a block in mk_env(), but was separated for re-use
684 sub save_trimmed_copy {
685     my ($self, $copy) = @_;
686
687     $self->copy($copy);
688     $self->volume($copy->call_number);
689     $self->title($self->volume->record);
690     $self->copy->call_number($self->volume->id);
691     $self->volume->record($self->title->id);
692     $self->is_precat(1) if $self->volume->id == OILS_PRECAT_CALL_NUMBER;
693     if($self->copy->deposit_amount and $self->copy->deposit_amount > 0) {
694         $self->is_deposit(1) if $U->is_true($self->copy->deposit);
695         $self->is_rental(1) unless $U->is_true($self->copy->deposit);
696     }
697 }
698
699 sub mk_env {
700     my $self = shift;
701     my $e = $self->editor;
702
703     # --------------------------------------------------------------------------
704     # Grab the fleshed copy
705     # --------------------------------------------------------------------------
706     unless($self->is_noncat) {
707         my $copy;
708         if($self->copy_id) {
709             $copy = $e->retrieve_asset_copy(
710                 [$self->copy_id, $MK_ENV_FLESH ]) or return $e->event;
711     
712         } elsif( $self->copy_barcode ) {
713     
714             $copy = $e->search_asset_copy(
715                 [{barcode => $self->copy_barcode, deleted => 'f'}, $MK_ENV_FLESH ])->[0];
716         } elsif( $self->reservation ) {
717             my $res = $e->json_query(
718                 {
719                     "select" => {"acp" => ["id"]},
720                     "from" => {
721                         "acp" => {
722                             "brsrc" => {
723                                 "fkey" => "barcode",
724                                 "field" => "barcode",
725                                 "join" => {
726                                     "bresv" => {
727                                         "fkey" => "id",
728                                         "field" => "current_resource"
729                                     }
730                                 }
731                             }
732                         }
733                     },
734                     "where" => {
735                         "+bresv" => {
736                             "id" => (ref $self->reservation) ?
737                                 $self->reservation->id : $self->reservation
738                         }
739                     }
740                 }
741             );
742             if (ref $res eq "ARRAY" and scalar @$res) {
743                 $logger->info("circulator: mapped reservation " .
744                     $self->reservation . " to copy " . $res->[0]->{"id"});
745                 $copy = $e->retrieve_asset_copy([$res->[0]->{"id"}, $MK_ENV_FLESH]);
746             }
747         }
748     
749         if($copy) {
750             $self->save_trimmed_copy($copy);
751         } else {
752             # We can't renew if there is no copy
753             return $self->bail_on_events(OpenILS::Event->new('ASSET_COPY_NOT_FOUND'))
754                 if $self->is_renewal;
755             $self->is_precat(1);
756         }
757     }
758
759     # --------------------------------------------------------------------------
760     # Grab the patron
761     # --------------------------------------------------------------------------
762     my $patron;
763     my $flesh = {
764         flesh => 1,
765         flesh_fields => {au => [ qw/ card / ]}
766     };
767
768     if( $self->patron_id ) {
769         $patron = $e->retrieve_actor_user([$self->patron_id, $flesh])
770             or return $self->bail_on_events(OpenILS::Event->new('ACTOR_USER_NOT_FOUND'));
771
772     } elsif( $self->patron_barcode ) {
773
774         # note: throwing ACTOR_USER_NOT_FOUND instead of ACTOR_CARD_NOT_FOUND is intentional
775         my $card = $e->search_actor_card({barcode => $self->patron_barcode})->[0] 
776             or return $self->bail_on_events(OpenILS::Event->new('ACTOR_USER_NOT_FOUND'));
777
778         $patron = $e->retrieve_actor_user($card->usr)
779             or return $self->bail_on_events(OpenILS::Event->new('ACTOR_USER_NOT_FOUND'));
780
781         # Use the card we looked up, not the patron's primary, for card active checks
782         $patron->card($card);
783
784     } else {
785         if( my $copy = $self->copy ) {
786
787             $flesh->{flesh} = 2;
788             $flesh->{flesh_fields}->{circ} = ['usr'];
789
790             my $circ = $e->search_action_circulation([
791                 {target_copy => $copy->id, checkin_time => undef}, $flesh
792             ])->[0];
793
794             if($circ) {
795                 $patron = $circ->usr;
796                 $circ->usr($patron->id); # de-flesh for consistency
797                 $self->circ($circ); 
798             }
799         }
800     }
801
802     return $self->bail_on_events(OpenILS::Event->new('ACTOR_USER_NOT_FOUND'))
803         unless $self->patron($patron) or $self->is_checkin;
804
805     unless($self->is_checkin) {
806
807         # Check for inactivity and patron reg. expiration
808
809         $self->bail_on_events(OpenILS::Event->new('PATRON_INACTIVE'))
810             unless $U->is_true($patron->active);
811     
812         $self->bail_on_events(OpenILS::Event->new('PATRON_CARD_INACTIVE'))
813             unless $U->is_true($patron->card->active);
814     
815         my $expire = DateTime::Format::ISO8601->new->parse_datetime(
816             cleanse_ISO8601($patron->expire_date));
817     
818         $self->bail_on_events(OpenILS::Event->new('PATRON_ACCOUNT_EXPIRED'))
819             if( CORE::time > $expire->epoch ) ;
820     }
821 }
822
823 # --------------------------------------------------------------------------
824 # This builds the script runner environment and fetches most of the
825 # objects we need
826 # --------------------------------------------------------------------------
827 sub mk_script_runner {
828     my $self = shift;
829     my $args = {};
830
831
832     my @fields = 
833         qw/copy copy_barcode copy_id patron 
834             patron_id patron_barcode volume title editor/;
835
836     # Translate our objects into the ScriptBuilder args hash
837     $$args{$_} = $self->$_() for @fields;
838
839     $args->{ignore_user_status} = 1 if $self->is_checkin;
840     $$args{fetch_patron_by_circ_copy} = 1;
841     $$args{fetch_patron_circ_info} = 1 unless $self->is_checkin;
842
843     if( my $pco = $self->pending_checkouts ) {
844         $logger->info("circulator: we were given a pending checkouts number of $pco");
845         $$args{patronItemsOut} = $pco;
846     }
847
848     # This fetches most of the objects we need
849     $self->script_runner(
850         OpenILS::Application::Circ::ScriptBuilder->build($args));
851
852     # Now we translate the ScriptBuilder objects back into self
853     $self->$_($$args{$_}) for @fields;
854
855     my @evts = @{$args->{_events}} if $args->{_events};
856
857     $logger->debug("circulator: script builder returned events: @evts") if @evts;
858
859
860     if(@evts) {
861         # Anything besides ASSET_COPY_NOT_FOUND will stop processing
862         if(!$self->is_noncat and 
863             @evts == 1 and 
864             $evts[0]->{textcode} eq 'ASSET_COPY_NOT_FOUND') {
865                 $self->is_precat(1);
866
867         } else {
868             my @e = grep { $_->{textcode} ne 'ASSET_COPY_NOT_FOUND' } @evts;
869             return $self->bail_on_events(@e);
870         }
871     }
872
873     if($self->copy) {
874         $self->is_precat(1) if $self->copy->call_number == OILS_PRECAT_CALL_NUMBER;
875         if($self->copy->deposit_amount and $self->copy->deposit_amount > 0) {
876             $self->is_deposit(1) if $U->is_true($self->copy->deposit);
877             $self->is_rental(1) unless $U->is_true($self->copy->deposit);
878         }
879     }
880
881     # We can't renew if there is no copy
882     return $self->bail_on_events(@evts) if 
883         $self->is_renewal and !$self->copy;
884
885     # Set some circ-specific flags in the script environment
886     my $evt = "environment";
887     $self->script_runner->insert("$evt.isRenewal", ($self->is_renewal) ? 1 : undef);
888
889     if( $self->is_noncat ) {
890       $self->script_runner->insert("$evt.isNonCat", 1);
891       $self->script_runner->insert("$evt.nonCatType", $self->noncat_type);
892     }
893
894     if( $self->is_precat ) {
895         $self->script_runner->insert("environment.isPrecat", 1, 1);
896     }
897
898     $self->script_runner->add_path( $_ ) for @$script_libs;
899
900     return 1;
901 }
902
903 # --------------------------------------------------------------------------
904 # Does the circ permit work
905 # --------------------------------------------------------------------------
906 sub do_permit {
907     my $self = shift;
908
909     $self->log_me("do_permit()");
910
911     unless( $self->editor->requestor->id == $self->patron->id ) {
912         return $self->bail_on_events($self->editor->event)
913             unless( $self->editor->allowed('VIEW_PERMIT_CHECKOUT') );
914     }
915
916     $self->check_captured_holds();
917     $self->do_copy_checks();
918     return if $self->bail_out;
919     $self->run_patron_permit_scripts();
920     $self->run_copy_permit_scripts() 
921         unless $self->is_precat or $self->is_noncat;
922     $self->check_item_deposit_events();
923     $self->override_events();
924     return if $self->bail_out;
925
926     if($self->is_precat and not $self->request_precat) {
927         $self->push_events(
928             OpenILS::Event->new(
929                 'ITEM_NOT_CATALOGED', payload => $self->mk_permit_key));
930         return $self->bail_out(1) unless $self->is_renewal;
931     }
932
933     $self->push_events(
934         OpenILS::Event->new('SUCCESS', payload => $self->mk_permit_key));
935 }
936
937 sub check_item_deposit_events {
938     my $self = shift;
939     $self->push_events(OpenILS::Event->new('ITEM_DEPOSIT_REQUIRED', payload => $self->copy)) 
940         if $self->is_deposit and not $self->is_deposit_exempt;
941     $self->push_events(OpenILS::Event->new('ITEM_RENTAL_FEE_REQUIRED', payload => $self->copy)) 
942         if $self->is_rental and not $self->is_rental_exempt;
943 }
944
945 # returns true if the user is not required to pay deposits
946 sub is_deposit_exempt {
947     my $self = shift;
948     my $pid = (ref $self->patron->profile) ?
949         $self->patron->profile->id : $self->patron->profile;
950     my $groups = $U->ou_ancestor_setting_value(
951         $self->circ_lib, 'circ.deposit.exempt_groups', $self->editor);
952     for my $grp (@$groups) {
953         return 1 if $self->is_group_descendant($grp, $pid);
954     }
955     return 0;
956 }
957
958 # returns true if the user is not required to pay rental fees
959 sub is_rental_exempt {
960     my $self = shift;
961     my $pid = (ref $self->patron->profile) ?
962         $self->patron->profile->id : $self->patron->profile;
963     my $groups = $U->ou_ancestor_setting_value(
964         $self->circ_lib, 'circ.rental.exempt_groups', $self->editor);
965     for my $grp (@$groups) {
966         return 1 if $self->is_group_descendant($grp, $pid);
967     }
968     return 0;
969 }
970
971 sub is_group_descendant {
972     my($self, $p_id, $c_id) = @_;
973     return 0 unless defined $p_id and defined $c_id;
974     return 1 if $c_id == $p_id;
975     while(my $grp = $user_groups{$c_id}) {
976         $c_id = $grp->parent;
977         return 0 unless defined $c_id;
978         return 1 if $c_id == $p_id;
979     }
980     return 0;
981 }
982
983 sub check_captured_holds {
984     my $self    = shift;
985     my $copy    = $self->copy;
986     my $patron  = $self->patron;
987
988     return undef unless $copy;
989
990     my $s = $U->copy_status($copy->status)->id;
991     return unless $s == OILS_COPY_STATUS_ON_HOLDS_SHELF;
992     $logger->info("circulator: copy is on holds shelf, searching for the correct hold");
993
994     # Item is on the holds shelf, make sure it's going to the right person
995     my $hold = $self->editor->search_action_hold_request(
996         [
997             { 
998                 current_copy        => $copy->id , 
999                 capture_time        => { '!=' => undef },
1000                 cancel_time         => undef, 
1001                 fulfillment_time    => undef 
1002             },
1003             { limit => 1 }
1004         ]
1005     )->[0];
1006
1007     if ($hold and $hold->usr == $patron->id) {
1008         $self->checkout_is_for_hold(1);
1009         return undef;
1010     }
1011
1012     $logger->info("circulator: this copy is needed by a different patron to fulfill a hold");
1013
1014     $self->push_events(OpenILS::Event->new('ITEM_ON_HOLDS_SHELF'));
1015 }
1016
1017
1018 sub do_copy_checks {
1019     my $self = shift;
1020     my $copy = $self->copy;
1021     return unless $copy;
1022
1023     my $stat = $U->copy_status($copy->status)->id;
1024
1025     # We cannot check out a copy if it is in-transit
1026     if( $stat == OILS_COPY_STATUS_IN_TRANSIT ) {
1027         return $self->bail_on_events(OpenILS::Event->new('COPY_IN_TRANSIT'));
1028     }
1029
1030     $self->handle_claims_returned();
1031     return if $self->bail_out;
1032
1033     # no claims returned circ was found, check if there is any open circ
1034     unless( $self->is_renewal ) {
1035
1036         my $circs = $self->editor->search_action_circulation(
1037             { target_copy => $copy->id, checkin_time => undef }
1038         );
1039
1040         if(my $old_circ = $circs->[0]) { # an open circ was found
1041
1042             my $payload = {copy => $copy};
1043
1044             if($old_circ->usr == $self->patron->id) {
1045                 
1046                 $payload->{old_circ} = $old_circ;
1047
1048                 # If there is an open circulation on the checkout item and an auto-renew 
1049                 # interval is defined, inform the caller that they should go 
1050                 # ahead and renew the item instead of warning about open circulations.
1051     
1052                 my $auto_renew_intvl = $U->ou_ancestor_setting_value(        
1053                     $self->circ_lib,
1054                     'circ.checkout_auto_renew_age', 
1055                     $self->editor
1056                 );
1057
1058                 if($auto_renew_intvl) {
1059                     my $intvl_seconds = OpenSRF::Utils->interval_to_seconds($auto_renew_intvl);
1060                     my $checkout_time = DateTime::Format::ISO8601->new->parse_datetime( cleanse_ISO8601($old_circ->xact_start) );
1061
1062                     if(DateTime->now > $checkout_time->add(seconds => $intvl_seconds)) {
1063                         $payload->{auto_renew} = 1;
1064                     }
1065                 }
1066             }
1067
1068             return $self->bail_on_events(
1069                 OpenILS::Event->new('OPEN_CIRCULATION_EXISTS', payload => $payload)
1070             );
1071         }
1072     }
1073 }
1074
1075 my $LEGACY_CIRC_EVENT_MAP = {
1076     'no_item' => 'ITEM_NOT_CATALOGED',
1077     'actor.usr.barred' => 'PATRON_BARRED',
1078     'asset.copy.circulate' =>  'COPY_CIRC_NOT_ALLOWED',
1079     'asset.copy.status' => 'COPY_NOT_AVAILABLE',
1080     'asset.copy_location.circulate' => 'COPY_CIRC_NOT_ALLOWED',
1081     'config.circ_matrix_test.circulate' => 'COPY_CIRC_NOT_ALLOWED',
1082     'config.circ_matrix_test.max_items_out' =>  'PATRON_EXCEEDS_CHECKOUT_COUNT',
1083     'config.circ_matrix_test.max_overdue' =>  'PATRON_EXCEEDS_OVERDUE_COUNT',
1084     'config.circ_matrix_test.max_fines' => 'PATRON_EXCEEDS_FINES',
1085     'config.circ_matrix_circ_mod_test' => 'PATRON_EXCEEDS_CHECKOUT_COUNT',
1086 };
1087
1088
1089 # ---------------------------------------------------------------------
1090 # This pushes any patron-related events into the list but does not
1091 # set bail_out for any events
1092 # ---------------------------------------------------------------------
1093 sub run_patron_permit_scripts {
1094     my $self        = shift;
1095     my $runner      = $self->script_runner;
1096     my $patronid    = $self->patron->id;
1097
1098     my @allevents; 
1099
1100     if(!$self->legacy_script_support) {
1101
1102         my $results = $self->run_indb_circ_test;
1103         unless($self->circ_test_success) {
1104             my @trimmed_results;
1105
1106             if ($self->is_noncat) {
1107                 # no_item result is OK during noncat checkout
1108                 @trimmed_results = grep { ($_->{fail_part} || '') ne 'no_item' } @$results;
1109
1110             } else {
1111
1112                 if ($self->checkout_is_for_hold) {
1113                     # if this checkout will fulfill a hold, ignore CIRC blocks
1114                     # and rely instead on the (later-checked) FULFILL block
1115
1116                     my @pen_names = grep {$_} map {$_->{fail_part}} @$results;
1117                     my $fblock_pens = $self->editor->search_config_standing_penalty(
1118                         {name => [@pen_names], block_list => {like => '%CIRC%'}});
1119
1120                     for my $res (@$results) {
1121                         my $name = $res->{fail_part} || '';
1122                         next if grep {$_->name eq $name} @$fblock_pens;
1123                         push(@trimmed_results, $res);
1124                     }
1125
1126                 } else { 
1127                     # not for hold or noncat
1128                     @trimmed_results = @$results;
1129                 }
1130             }
1131
1132             # update the final set of test results
1133             $self->matrix_test_result(\@trimmed_results); 
1134
1135             push @allevents, $self->matrix_test_result_events;
1136         }
1137
1138     } else {
1139
1140         # --------------------------------------------------------------------- 
1141         # # Now run the patron permit script 
1142         # ---------------------------------------------------------------------
1143         $runner->load($self->circ_permit_patron);
1144         my $result = $runner->run or 
1145             throw OpenSRF::EX::ERROR ("Circ Permit Patron Script Died: $@");
1146
1147         my $patron_events = $result->{events};
1148
1149         OpenILS::Utils::Penalty->calculate_penalties($self->editor, $self->patron->id, $self->circ_lib);
1150         my $mask = ($self->is_renewal) ? 'RENEW' : 'CIRC';
1151         my $penalties = OpenILS::Utils::Penalty->retrieve_penalties($self->editor, $patronid, $self->circ_lib, $mask);
1152         $penalties = $penalties->{fatal_penalties};
1153
1154         for my $pen (@$penalties) {
1155             # CIRC blocks are ignored if this is a FULFILL scenario
1156             next if $mask eq 'CIRC' and $self->checkout_is_for_hold;
1157             my $event = OpenILS::Event->new($pen->name);
1158             $event->{desc} = $pen->label;
1159             push(@allevents, $event);
1160         }
1161
1162         push(@allevents, OpenILS::Event->new($_)) for (@$patron_events);
1163     }
1164
1165     for (@allevents) {
1166        $_->{payload} = $self->copy if 
1167              ($_->{textcode} eq 'COPY_NOT_AVAILABLE');
1168     }
1169
1170     $logger->info("circulator: permit_patron script returned events: @allevents") if @allevents;
1171
1172     $self->push_events(@allevents);
1173 }
1174
1175 sub matrix_test_result_codes {
1176     my $self = shift;
1177     map { $_->{"fail_part"} } @{$self->matrix_test_result};
1178 }
1179
1180 sub matrix_test_result_events {
1181     my $self = shift;
1182     map {
1183         my $event = new OpenILS::Event(
1184             $LEGACY_CIRC_EVENT_MAP->{$_->{"fail_part"}} || $_->{"fail_part"}
1185         );
1186         $event->{"payload"} = {"fail_part" => $_->{"fail_part"}};
1187         $event;
1188     } (@{$self->matrix_test_result});
1189 }
1190
1191 sub run_indb_circ_test {
1192     my $self = shift;
1193     return $self->matrix_test_result if $self->matrix_test_result;
1194
1195     my $dbfunc = ($self->is_renewal) ? 
1196         'action.item_user_renew_test' : 'action.item_user_circ_test';
1197
1198     if( $self->is_precat && $self->request_precat) {
1199         $self->make_precat_copy;
1200         return if $self->bail_out;
1201     }
1202
1203     my $results = $self->editor->json_query(
1204         {   from => [
1205                 $dbfunc,
1206                 $self->circ_lib,
1207                 ($self->is_noncat or ($self->is_precat and !$self->override and !$self->is_renewal)) ? undef : $self->copy->id, 
1208                 $self->patron->id,
1209             ]
1210         }
1211     );
1212
1213     $self->circ_test_success($U->is_true($results->[0]->{success}));
1214
1215     if(my $mp = $results->[0]->{matchpoint}) {
1216         $logger->info("circulator: circ policy test found matchpoint built via rows " . $results->[0]->{buildrows});
1217         $self->circ_matrix_matchpoint($self->editor->retrieve_config_circ_matrix_matchpoint($mp));
1218         $self->circ_matrix_matchpoint->duration_rule($self->editor->retrieve_config_rules_circ_duration($results->[0]->{duration_rule}));
1219         if(defined($results->[0]->{renewals})) {
1220             $self->circ_matrix_matchpoint->duration_rule->max_renewals($results->[0]->{renewals});
1221         }
1222         $self->circ_matrix_matchpoint->recurring_fine_rule($self->editor->retrieve_config_rules_recurring_fine($results->[0]->{recurring_fine_rule}));
1223         if(defined($results->[0]->{grace_period})) {
1224             $self->circ_matrix_matchpoint->recurring_fine_rule->grace_period($results->[0]->{grace_period});
1225         }
1226         $self->circ_matrix_matchpoint->max_fine_rule($self->editor->retrieve_config_rules_max_fine($results->[0]->{max_fine_rule}));
1227         $self->circ_matrix_matchpoint->hard_due_date($self->editor->retrieve_config_hard_due_date($results->[0]->{hard_due_date}));
1228         # Grab the *last* response for limit_groups, where it is more likely to be filled
1229         $self->limit_groups($results->[-1]->{limit_groups});
1230     }
1231
1232     return $self->matrix_test_result($results);
1233 }
1234
1235 # ---------------------------------------------------------------------
1236 # given a use and copy, this will calculate the circulation policy
1237 # parameters.  Only works with in-db circ.
1238 # ---------------------------------------------------------------------
1239 sub do_inspect {
1240     my $self = shift;
1241
1242     return OpenILS::Event->new('ASSET_COPY_NOT_FOUND') unless $self->copy;
1243
1244     $self->run_indb_circ_test;
1245
1246     my $results = {
1247         circ_test_success => $self->circ_test_success,
1248         failure_events => [],
1249         failure_codes => [],
1250         matchpoint => $self->circ_matrix_matchpoint
1251     };
1252
1253     unless($self->circ_test_success) {
1254         $results->{"failure_codes"} = [ $self->matrix_test_result_codes ];
1255         $results->{"failure_events"} = [ $self->matrix_test_result_events ];
1256     }
1257
1258     if($self->circ_matrix_matchpoint) {
1259         my $duration_rule = $self->circ_matrix_matchpoint->duration_rule;
1260         my $recurring_fine_rule = $self->circ_matrix_matchpoint->recurring_fine_rule;
1261         my $max_fine_rule = $self->circ_matrix_matchpoint->max_fine_rule;
1262         my $hard_due_date = $self->circ_matrix_matchpoint->hard_due_date;
1263     
1264         my $policy = $self->get_circ_policy(
1265             $duration_rule, $recurring_fine_rule, $max_fine_rule, $hard_due_date);
1266     
1267         $$results{$_} = $$policy{$_} for keys %$policy;
1268     }
1269
1270     return $results;
1271 }
1272
1273 # ---------------------------------------------------------------------
1274 # Loads the circ policy info for duration, recurring fine, and max
1275 # fine based on the current copy
1276 # ---------------------------------------------------------------------
1277 sub get_circ_policy {
1278     my($self, $duration_rule, $recurring_fine_rule, $max_fine_rule, $hard_due_date) = @_;
1279
1280     my $policy = {
1281         duration_rule => $duration_rule->name,
1282         recurring_fine_rule => $recurring_fine_rule->name,
1283         max_fine_rule => $max_fine_rule->name,
1284         max_fine => $self->get_max_fine_amount($max_fine_rule),
1285         fine_interval => $recurring_fine_rule->recurrence_interval,
1286         renewal_remaining => $duration_rule->max_renewals,
1287         grace_period => $recurring_fine_rule->grace_period
1288     };
1289
1290     if($hard_due_date) {
1291         $policy->{duration_date_ceiling} = $hard_due_date->ceiling_date;
1292         $policy->{duration_date_ceiling_force} = $hard_due_date->forceto;
1293     }
1294     else {
1295         $policy->{duration_date_ceiling} = undef;
1296         $policy->{duration_date_ceiling_force} = undef;
1297     }
1298
1299     $policy->{duration} = $duration_rule->shrt
1300         if $self->copy->loan_duration == OILS_CIRC_DURATION_SHORT;
1301     $policy->{duration} = $duration_rule->normal
1302         if $self->copy->loan_duration == OILS_CIRC_DURATION_NORMAL;
1303     $policy->{duration} = $duration_rule->extended
1304         if $self->copy->loan_duration == OILS_CIRC_DURATION_EXTENDED;
1305
1306     $policy->{recurring_fine} = $recurring_fine_rule->low
1307         if $self->copy->fine_level == OILS_REC_FINE_LEVEL_LOW;
1308     $policy->{recurring_fine} = $recurring_fine_rule->normal
1309         if $self->copy->fine_level == OILS_REC_FINE_LEVEL_NORMAL;
1310     $policy->{recurring_fine} = $recurring_fine_rule->high
1311         if $self->copy->fine_level == OILS_REC_FINE_LEVEL_HIGH;
1312
1313     return $policy;
1314 }
1315
1316 sub get_max_fine_amount {
1317     my $self = shift;
1318     my $max_fine_rule = shift;
1319     my $max_amount = $max_fine_rule->amount;
1320
1321     # if is_percent is true then the max->amount is
1322     # use as a percentage of the copy price
1323     if ($U->is_true($max_fine_rule->is_percent)) {
1324         my $price = $U->get_copy_price($self->editor, $self->copy, $self->volume);
1325         $max_amount = $price * $max_fine_rule->amount / 100;
1326     } elsif (
1327         $U->ou_ancestor_setting_value(
1328             $self->circ_lib,
1329             'circ.max_fine.cap_at_price',
1330             $self->editor
1331         )
1332     ) {
1333         my $price = $U->get_copy_price($self->editor, $self->copy, $self->volume);
1334         $max_amount = ( $price && $max_amount > $price ) ? $price : $max_amount;
1335     }
1336
1337     return $max_amount;
1338 }
1339
1340
1341
1342 sub run_copy_permit_scripts {
1343     my $self = shift;
1344     my $copy = $self->copy || return;
1345     my $runner = $self->script_runner;
1346
1347     my @allevents;
1348
1349     if(!$self->legacy_script_support) {
1350         my $results = $self->run_indb_circ_test;
1351         push @allevents, $self->matrix_test_result_events
1352             unless $self->circ_test_success;
1353     } else {
1354     
1355        # ---------------------------------------------------------------------
1356        # Capture all of the copy permit events
1357        # ---------------------------------------------------------------------
1358        $runner->load($self->circ_permit_copy);
1359        my $result = $runner->run or 
1360             throw OpenSRF::EX::ERROR ("Circ Permit Copy Script Died: $@");
1361        my $copy_events = $result->{events};
1362
1363        # ---------------------------------------------------------------------
1364        # Now collect all of the events together
1365        # ---------------------------------------------------------------------
1366        push( @allevents, OpenILS::Event->new($_)) for @$copy_events;
1367     }
1368
1369     # See if this copy has an alert message
1370     my $ae = $self->check_copy_alert();
1371     push( @allevents, $ae ) if $ae;
1372
1373    # uniquify the events
1374    my %hash = map { ($_->{ilsevent} => $_) } @allevents;
1375    @allevents = values %hash;
1376
1377     $logger->info("circulator: permit_copy script returned events: @allevents") if @allevents;
1378
1379     $self->push_events(@allevents);
1380 }
1381
1382
1383 sub check_copy_alert {
1384     my $self = shift;
1385     return undef if $self->is_renewal;
1386     return OpenILS::Event->new(
1387         'COPY_ALERT_MESSAGE', payload => $self->copy->alert_message)
1388         if $self->copy and $self->copy->alert_message;
1389     return undef;
1390 }
1391
1392
1393
1394 # --------------------------------------------------------------------------
1395 # If the call is overriding and has permissions to override every collected
1396 # event, the are cleared.  Any event that the caller does not have
1397 # permission to override, will be left in the event list and bail_out will
1398 # be set
1399 # XXX We need code in here to cancel any holds/transits on copies 
1400 # that are being force-checked out
1401 # --------------------------------------------------------------------------
1402 sub override_events {
1403     my $self = shift;
1404     my @events = @{$self->events};
1405     return unless @events;
1406     my $oargs = $self->override_args;
1407
1408     if(!$self->override) {
1409         return $self->bail_out(1) 
1410             if( @events > 1 or $events[0]->{textcode} ne 'SUCCESS' );
1411     }   
1412
1413     $self->events([]);
1414     
1415     for my $e (@events) {
1416         my $tc = $e->{textcode};
1417         next if $tc eq 'SUCCESS';
1418         if($oargs->{all} || grep { $_ eq $tc } @{$oargs->{events}}) {
1419             my $ov = "$tc.override";
1420             $logger->info("circulator: attempting to override event: $ov");
1421
1422             return $self->bail_on_events($self->editor->event)
1423                 unless( $self->editor->allowed($ov) );
1424         } else {
1425             return $self->bail_out(1);
1426         }
1427    }
1428 }
1429     
1430
1431 # --------------------------------------------------------------------------
1432 # If there is an open claimsreturn circ on the requested copy, close the 
1433 # circ if overriding, otherwise bail out
1434 # --------------------------------------------------------------------------
1435 sub handle_claims_returned {
1436     my $self = shift;
1437     my $copy = $self->copy;
1438
1439     my $CR = $self->editor->search_action_circulation(
1440         {   
1441             target_copy     => $copy->id,
1442             stop_fines      => OILS_STOP_FINES_CLAIMSRETURNED,
1443             checkin_time    => undef,
1444         }
1445     );
1446
1447     return unless ($CR = $CR->[0]); 
1448
1449     my $evt;
1450
1451     # - If the caller has set the override flag, we will check the item in
1452     if($self->override && ($self->override_args->{all} || grep { $_ eq 'CIRC_CLAIMS_RETURNED' } @{$self->override_args->{events}}) ) {
1453
1454         $CR->checkin_time('now');   
1455         $CR->checkin_scan_time('now');   
1456         $CR->checkin_lib($self->circ_lib);
1457         $CR->checkin_workstation($self->editor->requestor->wsid);
1458         $CR->checkin_staff($self->editor->requestor->id);
1459
1460         $evt = $self->editor->event 
1461             unless $self->editor->update_action_circulation($CR);
1462
1463     } else {
1464         $evt = OpenILS::Event->new('CIRC_CLAIMS_RETURNED');
1465     }
1466
1467     $self->bail_on_events($evt) if $evt;
1468     return;
1469 }
1470
1471
1472 # --------------------------------------------------------------------------
1473 # This performs the checkout
1474 # --------------------------------------------------------------------------
1475 sub do_checkout {
1476     my $self = shift;
1477
1478     $self->log_me("do_checkout()");
1479
1480     # make sure perms are good if this isn't a renewal
1481     unless( $self->is_renewal ) {
1482         return $self->bail_on_events($self->editor->event)
1483             unless( $self->editor->allowed('COPY_CHECKOUT') );
1484     }
1485
1486     # verify the permit key
1487     unless( $self->check_permit_key ) {
1488         if( $self->permit_override ) {
1489             return $self->bail_on_events($self->editor->event)
1490                 unless $self->editor->allowed('CIRC_PERMIT_OVERRIDE');
1491         } else {
1492             return $self->bail_on_events(OpenILS::Event->new('CIRC_PERMIT_BAD_KEY'))
1493         }   
1494     }
1495
1496     # if this is a non-cataloged circ, build the circ and finish
1497     if( $self->is_noncat ) {
1498         $self->checkout_noncat;
1499         $self->push_events(
1500             OpenILS::Event->new('SUCCESS', 
1501             payload => { noncat_circ => $self->circ }));
1502         return;
1503     }
1504
1505     if( $self->is_precat ) {
1506         $self->make_precat_copy;
1507         return if $self->bail_out;
1508
1509     } elsif( $self->copy->call_number == OILS_PRECAT_CALL_NUMBER ) {
1510         return $self->bail_on_events(OpenILS::Event->new('ITEM_NOT_CATALOGED'));
1511     }
1512
1513     $self->do_copy_checks;
1514     return if $self->bail_out;
1515
1516     $self->run_checkout_scripts();
1517     return if $self->bail_out;
1518
1519     $self->build_checkout_circ_object();
1520     return if $self->bail_out;
1521
1522     my $modify_to_start = $self->booking_adjusted_due_date();
1523     return if $self->bail_out;
1524
1525     $self->apply_modified_due_date($modify_to_start);
1526     return if $self->bail_out;
1527
1528     return $self->bail_on_events($self->editor->event)
1529         unless $self->editor->create_action_circulation($self->circ);
1530
1531     # refresh the circ to force local time zone for now
1532     $self->circ($self->editor->retrieve_action_circulation($self->circ->id));
1533
1534     if($self->limit_groups) {
1535         $self->editor->json_query({ from => ['action.link_circ_limit_groups', $self->circ->id, $self->limit_groups] });
1536     }
1537
1538     $self->copy->status(OILS_COPY_STATUS_CHECKED_OUT);
1539     $self->update_copy;
1540     return if $self->bail_out;
1541
1542     $self->apply_deposit_fee();
1543     return if $self->bail_out;
1544
1545     $self->handle_checkout_holds();
1546     return if $self->bail_out;
1547
1548     # ------------------------------------------------------------------------------
1549     # Update the patron penalty info in the DB.  Run it for permit-overrides 
1550     # since the penalties are not updated during the permit phase
1551     # ------------------------------------------------------------------------------
1552     OpenILS::Utils::Penalty->calculate_penalties($self->editor, $self->patron->id, $self->circ_lib);
1553
1554     my $record = $U->record_to_mvr($self->title) unless $self->is_precat;
1555     
1556     my $pcirc;
1557     if($self->is_renewal) {
1558         # flesh the billing summary for the checked-in circ
1559         $pcirc = $self->editor->retrieve_action_circulation([
1560             $self->parent_circ,
1561             {flesh => 2, flesh_fields => {circ => ['billable_transaction'], mbt => ['summary']}}
1562         ]);
1563     }
1564
1565     $self->push_events(
1566         OpenILS::Event->new('SUCCESS',
1567             payload  => {
1568                 copy             => $U->unflesh_copy($self->copy),
1569                 volume           => $self->volume,
1570                 circ             => $self->circ,
1571                 record           => $record,
1572                 holds_fulfilled  => $self->fulfilled_holds,
1573                 deposit_billing  => $self->deposit_billing,
1574                 rental_billing   => $self->rental_billing,
1575                 parent_circ      => $pcirc,
1576                 patron           => ($self->return_patron) ? $self->patron : undef,
1577                 patron_money     => $self->editor->retrieve_money_user_summary($self->patron->id)
1578             }
1579         )
1580     );
1581 }
1582
1583 sub apply_deposit_fee {
1584     my $self = shift;
1585     my $copy = $self->copy;
1586     return unless 
1587         ($self->is_deposit and not $self->is_deposit_exempt) or 
1588         ($self->is_rental and not $self->is_rental_exempt);
1589
1590     return if $self->is_deposit and $self->skip_deposit_fee;
1591     return if $self->is_rental and $self->skip_rental_fee;
1592
1593     my $bill = Fieldmapper::money::billing->new;
1594     my $amount = $copy->deposit_amount;
1595     my $billing_type;
1596     my $btype;
1597
1598     if($self->is_deposit) {
1599         $billing_type = OILS_BILLING_TYPE_DEPOSIT;
1600         $btype = 5;
1601         $self->deposit_billing($bill);
1602     } else {
1603         $billing_type = OILS_BILLING_TYPE_RENTAL;
1604         $btype = 6;
1605         $self->rental_billing($bill);
1606     }
1607
1608     $bill->xact($self->circ->id);
1609     $bill->amount($amount);
1610     $bill->note(OILS_BILLING_NOTE_SYSTEM);
1611     $bill->billing_type($billing_type);
1612     $bill->btype($btype);
1613     $self->editor->create_money_billing($bill) or $self->bail_on_events($self->editor->event);
1614
1615     $logger->info("circulator: charged $amount on checkout with billing type $billing_type");
1616 }
1617
1618 sub update_copy {
1619     my $self = shift;
1620     my $copy = $self->copy;
1621
1622     my $stat = $copy->status if ref $copy->status;
1623     my $loc = $copy->location if ref $copy->location;
1624     my $circ_lib = $copy->circ_lib if ref $copy->circ_lib;
1625
1626     $copy->status($stat->id) if $stat;
1627     $copy->location($loc->id) if $loc;
1628     $copy->circ_lib($circ_lib->id) if $circ_lib;
1629     $copy->editor($self->editor->requestor->id);
1630     $copy->edit_date('now');
1631     $copy->age_protect($copy->age_protect->id) if ref $copy->age_protect;
1632
1633     return $self->bail_on_events($self->editor->event)
1634         unless $self->editor->update_asset_copy($self->copy);
1635
1636     $copy->status($U->copy_status($copy->status));
1637     $copy->location($loc) if $loc;
1638     $copy->circ_lib($circ_lib) if $circ_lib;
1639 }
1640
1641 sub update_reservation {
1642     my $self = shift;
1643     my $reservation = $self->reservation;
1644
1645     my $usr = $reservation->usr;
1646     my $target_rt = $reservation->target_resource_type;
1647     my $target_r = $reservation->target_resource;
1648     my $current_r = $reservation->current_resource;
1649
1650     $reservation->usr($usr->id) if ref $usr;
1651     $reservation->target_resource_type($target_rt->id) if ref $target_rt;
1652     $reservation->target_resource($target_r->id) if ref $target_r;
1653     $reservation->current_resource($current_r->id) if ref $current_r;
1654
1655     return $self->bail_on_events($self->editor->event)
1656         unless $self->editor->update_booking_reservation($self->reservation);
1657
1658     my $evt;
1659     ($reservation, $evt) = $U->fetch_booking_reservation($reservation->id);
1660     $self->reservation($reservation);
1661 }
1662
1663
1664 sub bail_on_events {
1665     my( $self, @evts ) = @_;
1666     $self->push_events(@evts);
1667     $self->bail_out(1);
1668 }
1669
1670 # ------------------------------------------------------------------------------
1671 # A hold FULFILL block is just like a CIRC block, except that FULFILL only
1672 # affects copies that will fulfill holds and CIRC affects all other copies.
1673 # If blocks exists, bail, push Events onto the event pile, and return true.
1674 # ------------------------------------------------------------------------------
1675 sub check_hold_fulfill_blocks {
1676     my $self = shift;
1677
1678     # See if the user has any penalties applied that prevent hold fulfillment
1679     my $pens = $self->editor->json_query({
1680         select => {csp => ['name', 'label']},
1681         from => {ausp => {csp => {}}},
1682         where => {
1683             '+ausp' => {
1684                 usr => $self->patron->id,
1685                 org_unit => $U->get_org_full_path($self->circ_lib),
1686                 '-or' => [
1687                     {stop_date => undef},
1688                     {stop_date => {'>' => 'now'}}
1689                 ]
1690             },
1691             '+csp' => {block_list => {'like' => '%FULFILL%'}}
1692         }
1693     });
1694
1695     return 0 unless @$pens;
1696
1697     for my $pen (@$pens) {
1698         $logger->info("circulator: patron has hold FULFILL block " . $pen->{name});
1699         my $event = OpenILS::Event->new($pen->{name});
1700         $event->{desc} = $pen->{label};
1701         $self->push_events($event);
1702     }
1703
1704     $self->override_events;
1705     return $self->bail_out;
1706 }
1707
1708
1709 # ------------------------------------------------------------------------------
1710 # When an item is checked out, see if we can fulfill a hold for this patron
1711 # ------------------------------------------------------------------------------
1712 sub handle_checkout_holds {
1713    my $self    = shift;
1714    my $copy    = $self->copy;
1715    my $patron  = $self->patron;
1716
1717    my $e = $self->editor;
1718    $self->fulfilled_holds([]);
1719
1720    # non-cats can't fulfill a hold
1721    return if $self->is_noncat;
1722
1723     my $hold = $e->search_action_hold_request({   
1724         current_copy        => $copy->id , 
1725         cancel_time         => undef, 
1726         fulfillment_time    => undef,
1727         '-or' => [
1728             {expire_time => undef},
1729             {expire_time => {'>' => 'now'}}
1730         ]
1731     })->[0];
1732
1733     if($hold and $hold->usr != $patron->id) {
1734         # reset the hold since the copy is now checked out
1735     
1736         $logger->info("circulator: un-targeting hold ".$hold->id.
1737             " because copy ".$copy->id." is getting checked out");
1738
1739         $hold->clear_prev_check_time; 
1740         $hold->clear_current_copy;
1741         $hold->clear_capture_time;
1742         $hold->clear_shelf_time;
1743         $hold->clear_shelf_expire_time;
1744         $hold->clear_current_shelf_lib;
1745
1746         return $self->bail_on_event($e->event)
1747             unless $e->update_action_hold_request($hold);
1748
1749         $hold = undef;
1750     }
1751
1752     unless($hold) {
1753         $hold = $self->find_related_user_hold($copy, $patron) or return;
1754         $logger->info("circulator: found related hold to fulfill in checkout");
1755     }
1756
1757     return if $self->check_hold_fulfill_blocks;
1758
1759     $logger->debug("circulator: checkout fulfilling hold " . $hold->id);
1760
1761     # if the hold was never officially captured, capture it.
1762     $hold->current_copy($copy->id);
1763     $hold->capture_time('now') unless $hold->capture_time;
1764     $hold->fulfillment_time('now');
1765     $hold->fulfillment_staff($e->requestor->id);
1766     $hold->fulfillment_lib($self->circ_lib);
1767
1768     return $self->bail_on_events($e->event)
1769         unless $e->update_action_hold_request($hold);
1770
1771     return $self->fulfilled_holds([$hold->id]);
1772 }
1773
1774
1775 # ------------------------------------------------------------------------------
1776 # If the circ.checkout_fill_related_hold setting is turned on and no hold for
1777 # the patron directly targets the checked out item, see if there is another hold 
1778 # for the patron that could be fulfilled by the checked out item.  Fulfill the
1779 # oldest hold and only fulfill 1 of them.
1780
1781 # For "another hold":
1782 #
1783 # First, check for one that the copy matches via hold_copy_map, ensuring that
1784 # *any* hold type that this copy could fill may end up filled.
1785 #
1786 # Then, if circ.checkout_fill_related_hold_exact_match_only is not enabled, look
1787 # for a Title (T) or Volume (V) hold that matches the item. This allows items
1788 # that are non-requestable to count as capturing those hold types.
1789 # ------------------------------------------------------------------------------
1790 sub find_related_user_hold {
1791     my($self, $copy, $patron) = @_;
1792     my $e = $self->editor;
1793
1794     # holds on precat copies are always copy-level, so this call will
1795     # always return undef.  Exit early.
1796     return undef if $self->is_precat;
1797
1798     return undef unless $U->ou_ancestor_setting_value(        
1799         $self->circ_lib, 'circ.checkout_fills_related_hold', $e);
1800
1801     # find the oldest unfulfilled hold that has not yet hit the holds shelf.
1802     my $args = {
1803         select => {ahr => ['id']}, 
1804         from => {
1805             ahr => {
1806                 ahcm => {
1807                     field => 'hold',
1808                     fkey => 'id'
1809                 },
1810                 acp => {
1811                     field => 'id', 
1812                     fkey => 'current_copy',
1813                     type => 'left' # there may be no current_copy
1814                 }
1815             }
1816         }, 
1817         where => {
1818             '+ahr' => {
1819                 usr => $patron->id,
1820                 fulfillment_time => undef,
1821                 cancel_time => undef,
1822                '-or' => [
1823                     {expire_time => undef},
1824                     {expire_time => {'>' => 'now'}}
1825                 ]
1826             },
1827             '+ahcm' => {
1828                 target_copy => $self->copy->id
1829             },
1830             '+acp' => {
1831                 '-or' => [
1832                     {id => undef}, # left-join copy may be nonexistent
1833                     {status => {'!=' => OILS_COPY_STATUS_ON_HOLDS_SHELF}},
1834                 ]
1835             }
1836         },
1837         order_by => {ahr => {request_time => {direction => 'asc'}}},
1838         limit => 1
1839     };
1840
1841     my $hold_info = $e->json_query($args)->[0];
1842     return $e->retrieve_action_hold_request($hold_info->{id}) if $hold_info;
1843     return undef if $U->ou_ancestor_setting_value(        
1844         $self->circ_lib, 'circ.checkout_fills_related_hold_exact_match_only', $e);
1845
1846     # find the oldest unfulfilled hold that has not yet hit the holds shelf.
1847     $args = {
1848         select => {ahr => ['id']}, 
1849         from => {
1850             ahr => {
1851                 acp => {
1852                     field => 'id', 
1853                     fkey => 'current_copy',
1854                     type => 'left' # there may be no current_copy
1855                 }
1856             }
1857         }, 
1858         where => {
1859             '+ahr' => {
1860                 usr => $patron->id,
1861                 fulfillment_time => undef,
1862                 cancel_time => undef,
1863                '-or' => [
1864                     {expire_time => undef},
1865                     {expire_time => {'>' => 'now'}}
1866                 ]
1867             },
1868             '-or' => [
1869                 {
1870                     '+ahr' => { 
1871                         hold_type => 'V',
1872                         target => $self->volume->id
1873                     }
1874                 },
1875                 { 
1876                     '+ahr' => { 
1877                         hold_type => 'T',
1878                         target => $self->title->id
1879                     }
1880                 },
1881             ],
1882             '+acp' => {
1883                 '-or' => [
1884                     {id => undef}, # left-join copy may be nonexistent
1885                     {status => {'!=' => OILS_COPY_STATUS_ON_HOLDS_SHELF}},
1886                 ]
1887             }
1888         },
1889         order_by => {ahr => {request_time => {direction => 'asc'}}},
1890         limit => 1
1891     };
1892
1893     $hold_info = $e->json_query($args)->[0];
1894     return $e->retrieve_action_hold_request($hold_info->{id}) if $hold_info;
1895     return undef;
1896 }
1897
1898
1899 sub run_checkout_scripts {
1900     my $self = shift;
1901     my $nobail = shift;
1902
1903     my $evt;
1904     my $runner = $self->script_runner;
1905
1906     my $duration;
1907     my $recurring;
1908     my $max_fine;
1909     my $hard_due_date;
1910     my $duration_name;
1911     my $recurring_name;
1912     my $max_fine_name;
1913     my $hard_due_date_name;
1914
1915     if(!$self->legacy_script_support) {
1916         $self->run_indb_circ_test();
1917         $duration = $self->circ_matrix_matchpoint->duration_rule;
1918         $recurring = $self->circ_matrix_matchpoint->recurring_fine_rule;
1919         $max_fine = $self->circ_matrix_matchpoint->max_fine_rule;
1920         $hard_due_date = $self->circ_matrix_matchpoint->hard_due_date;
1921
1922     } else {
1923
1924        $runner->load($self->circ_duration);
1925
1926        my $result = $runner->run or 
1927             throw OpenSRF::EX::ERROR ("Circ Duration Script Died: $@");
1928
1929        $duration_name   = $result->{durationRule};
1930        $recurring_name  = $result->{recurringFinesRule};
1931        $max_fine_name   = $result->{maxFine};
1932        $hard_due_date_name  = $result->{hardDueDate};
1933     }
1934
1935     $duration_name = $duration->name if $duration;
1936     if( $duration_name ne OILS_UNLIMITED_CIRC_DURATION ) {
1937
1938         unless($duration) {
1939             ($duration, $evt) = $U->fetch_circ_duration_by_name($duration_name);
1940             return $self->bail_on_events($evt) if ($evt && !$nobail);
1941         
1942             ($recurring, $evt) = $U->fetch_recurring_fine_by_name($recurring_name);
1943             return $self->bail_on_events($evt) if ($evt && !$nobail);
1944         
1945             ($max_fine, $evt) = $U->fetch_max_fine_by_name($max_fine_name);
1946             return $self->bail_on_events($evt) if ($evt && !$nobail);
1947
1948             if($hard_due_date_name) {
1949                 ($hard_due_date, $evt) = $U->fetch_hard_due_date_by_name($hard_due_date_name);
1950                 return $self->bail_on_events($evt) if ($evt && !$nobail);
1951             }
1952         }
1953
1954     } else {
1955
1956         # The item circulates with an unlimited duration
1957         $duration   = undef;
1958         $recurring  = undef;
1959         $max_fine   = undef;
1960         $hard_due_date = undef;
1961     }
1962
1963    $self->duration_rule($duration);
1964    $self->recurring_fines_rule($recurring);
1965    $self->max_fine_rule($max_fine);
1966    $self->hard_due_date($hard_due_date);
1967 }
1968
1969
1970 sub build_checkout_circ_object {
1971     my $self = shift;
1972
1973    my $circ       = Fieldmapper::action::circulation->new;
1974    my $duration   = $self->duration_rule;
1975    my $max        = $self->max_fine_rule;
1976    my $recurring  = $self->recurring_fines_rule;
1977    my $hard_due_date    = $self->hard_due_date;
1978    my $copy       = $self->copy;
1979    my $patron     = $self->patron;
1980    my $duration_date_ceiling;
1981    my $duration_date_ceiling_force;
1982
1983     if( $duration ) {
1984
1985         my $policy = $self->get_circ_policy($duration, $recurring, $max, $hard_due_date);
1986         $duration_date_ceiling = $policy->{duration_date_ceiling};
1987         $duration_date_ceiling_force = $policy->{duration_date_ceiling_force};
1988
1989         my $dname = $duration->name;
1990         my $mname = $max->name;
1991         my $rname = $recurring->name;
1992         my $hdname = ''; 
1993         if($hard_due_date) {
1994             $hdname = $hard_due_date->name;
1995         }
1996
1997         $logger->debug("circulator: building circulation ".
1998             "with duration=$dname, maxfine=$mname, recurring=$rname, hard due date=$hdname");
1999     
2000         $circ->duration($policy->{duration});
2001         $circ->recurring_fine($policy->{recurring_fine});
2002         $circ->duration_rule($duration->name);
2003         $circ->recurring_fine_rule($recurring->name);
2004         $circ->max_fine_rule($max->name);
2005         $circ->max_fine($policy->{max_fine});
2006         $circ->fine_interval($recurring->recurrence_interval);
2007         $circ->renewal_remaining($duration->max_renewals);
2008         $circ->grace_period($policy->{grace_period});
2009
2010     } else {
2011
2012         $logger->info("circulator: copy found with an unlimited circ duration");
2013         $circ->duration_rule(OILS_UNLIMITED_CIRC_DURATION);
2014         $circ->recurring_fine_rule(OILS_UNLIMITED_CIRC_DURATION);
2015         $circ->max_fine_rule(OILS_UNLIMITED_CIRC_DURATION);
2016         $circ->renewal_remaining(0);
2017         $circ->grace_period(0);
2018     }
2019
2020    $circ->target_copy( $copy->id );
2021    $circ->usr( $patron->id );
2022    $circ->circ_lib( $self->circ_lib );
2023    $circ->workstation($self->editor->requestor->wsid) 
2024     if defined $self->editor->requestor->wsid;
2025
2026     # renewals maintain a link to the parent circulation
2027     $circ->parent_circ($self->parent_circ);
2028
2029    if( $self->is_renewal ) {
2030       $circ->opac_renewal('t') if $self->opac_renewal;
2031       $circ->phone_renewal('t') if $self->phone_renewal;
2032       $circ->desk_renewal('t') if $self->desk_renewal;
2033       $circ->renewal_remaining($self->renewal_remaining);
2034       $circ->circ_staff($self->editor->requestor->id);
2035    }
2036
2037
2038     # if the user provided an overiding checkout time,
2039     # (e.g. the checkout really happened several hours ago), then
2040     # we apply that here.  Does this need a perm??
2041     $circ->xact_start(cleanse_ISO8601($self->checkout_time))
2042         if $self->checkout_time;
2043
2044     # if a patron is renewing, 'requestor' will be the patron
2045     $circ->circ_staff($self->editor->requestor->id);
2046     $circ->due_date( $self->create_due_date($circ->duration, $duration_date_ceiling, $duration_date_ceiling_force, $circ->xact_start) ) if $circ->duration;
2047
2048     $self->circ($circ);
2049 }
2050
2051 sub do_reservation_pickup {
2052     my $self = shift;
2053
2054     $self->log_me("do_reservation_pickup()");
2055
2056     $self->reservation->pickup_time('now');
2057
2058     if (
2059         $self->reservation->current_resource &&
2060         $U->is_true($self->reservation->target_resource_type->catalog_item)
2061     ) {
2062         # We used to try to set $self->copy and $self->patron here,
2063         # but that should already be done.
2064
2065         $self->run_checkout_scripts(1);
2066
2067         my $duration   = $self->duration_rule;
2068         my $max        = $self->max_fine_rule;
2069         my $recurring  = $self->recurring_fines_rule;
2070
2071         if ($duration && $max && $recurring) {
2072             my $policy = $self->get_circ_policy($duration, $recurring, $max);
2073
2074             my $dname = $duration->name;
2075             my $mname = $max->name;
2076             my $rname = $recurring->name;
2077
2078             $logger->debug("circulator: updating reservation ".
2079                 "with duration=$dname, maxfine=$mname, recurring=$rname");
2080
2081             $self->reservation->fine_amount($policy->{recurring_fine});
2082             $self->reservation->max_fine($policy->{max_fine});
2083             $self->reservation->fine_interval($recurring->recurrence_interval);
2084         }
2085
2086         $self->copy->status(OILS_COPY_STATUS_CHECKED_OUT);
2087         $self->update_copy();
2088
2089     } else {
2090         $self->reservation->fine_amount(
2091             $self->reservation->target_resource_type->fine_amount
2092         );
2093         $self->reservation->max_fine(
2094             $self->reservation->target_resource_type->max_fine
2095         );
2096         $self->reservation->fine_interval(
2097             $self->reservation->target_resource_type->fine_interval
2098         );
2099     }
2100
2101     $self->update_reservation();
2102 }
2103
2104 sub do_reservation_return {
2105     my $self = shift;
2106     my $request = shift;
2107
2108     $self->log_me("do_reservation_return()");
2109
2110     if (not ref $self->reservation) {
2111         my ($reservation, $evt) =
2112             $U->fetch_booking_reservation($self->reservation);
2113         return $self->bail_on_events($evt) if $evt;
2114         $self->reservation($reservation);
2115     }
2116
2117     $self->generate_fines(1);
2118     $self->reservation->return_time('now');
2119     $self->update_reservation();
2120     $self->reshelve_copy if $self->copy;
2121
2122     if ( $self->reservation->current_resource && $self->reservation->current_resource->catalog_item ) {
2123         $self->copy( $self->reservation->current_resource->catalog_item );
2124     }
2125 }
2126
2127 sub booking_adjusted_due_date {
2128     my $self = shift;
2129     my $circ = $self->circ;
2130     my $copy = $self->copy;
2131
2132     return undef unless $self->use_booking;
2133
2134     my $changed;
2135
2136     if( $self->due_date ) {
2137
2138         return $self->bail_on_events($self->editor->event)
2139             unless $self->editor->allowed('CIRC_OVERRIDE_DUE_DATE', $self->circ_lib);
2140
2141        $circ->due_date(cleanse_ISO8601($self->due_date));
2142
2143     } else {
2144
2145         return unless $copy and $circ->due_date;
2146     }
2147
2148     my $booking_items = $self->editor->search_booking_resource( { barcode => $copy->barcode } );
2149     if (@$booking_items) {
2150         my $booking_item = $booking_items->[0];
2151         my $resource_type = $self->editor->retrieve_booking_resource_type( $booking_item->type );
2152
2153         my $stop_circ_setting = $U->ou_ancestor_setting_value( $self->circ_lib, 'circ.booking_reservation.stop_circ', $self->editor );
2154         my $shorten_circ_setting = $resource_type->elbow_room ||
2155             $U->ou_ancestor_setting_value( $self->circ_lib, 'circ.booking_reservation.default_elbow_room', $self->editor ) ||
2156             '0 seconds';
2157
2158         my $booking_ses = OpenSRF::AppSession->create( 'open-ils.booking' );
2159         my $bookings = $booking_ses->request(
2160             'open-ils.booking.reservations.filtered_id_list', $self->editor->authtoken,
2161             { resource => $booking_item->id, search_start => 'now', search_end => $circ->due_date, fields => { cancel_time => undef, return_time => undef}}
2162         )->gather(1);
2163         $booking_ses->disconnect;
2164         
2165         my $dt_parser = DateTime::Format::ISO8601->new;
2166         my $due_date = $dt_parser->parse_datetime( cleanse_ISO8601($circ->due_date) );
2167
2168         for my $bid (@$bookings) {
2169
2170             my $booking = $self->editor->retrieve_booking_reservation( $bid );
2171
2172             my $booking_start = $dt_parser->parse_datetime( cleanse_ISO8601($booking->start_time) );
2173             my $booking_end = $dt_parser->parse_datetime( cleanse_ISO8601($booking->end_time) );
2174
2175             return $self->bail_on_events( OpenILS::Event->new('COPY_RESERVED') )
2176                 if ($booking_start < DateTime->now);
2177
2178
2179             if ($U->is_true($stop_circ_setting)) {
2180                 $self->bail_on_events( OpenILS::Event->new('COPY_RESERVED') ); 
2181             } else {
2182                 $due_date = $booking_start->subtract( seconds => interval_to_seconds($shorten_circ_setting) );
2183                 $self->bail_on_events( OpenILS::Event->new('COPY_RESERVED') ) if ($due_date < DateTime->now); 
2184             }
2185             
2186             # We set the circ duration here only to affect the logic that will
2187             # later (in a DB trigger) mangle the time part of the due date to
2188             # 11:59pm. Having any circ duration that is not a whole number of
2189             # days is enough to prevent the "correction."
2190             my $new_circ_duration = $due_date->epoch - time;
2191             $new_circ_duration++ if $new_circ_duration % 86400 == 0;
2192             $circ->duration("$new_circ_duration seconds");
2193
2194             $circ->due_date(cleanse_ISO8601($due_date->strftime('%FT%T%z')));
2195             $changed = 1;
2196         }
2197
2198         return $self->bail_on_events($self->editor->event)
2199             unless $self->editor->allowed('CIRC_OVERRIDE_DUE_DATE', $self->circ_lib);
2200     }
2201
2202     return $changed;
2203 }
2204
2205 sub apply_modified_due_date {
2206     my $self = shift;
2207     my $shift_earlier = shift;
2208     my $circ = $self->circ;
2209     my $copy = $self->copy;
2210
2211    if( $self->due_date ) {
2212
2213         return $self->bail_on_events($self->editor->event)
2214             unless $self->editor->allowed('CIRC_OVERRIDE_DUE_DATE', $self->circ_lib);
2215
2216       $circ->due_date(cleanse_ISO8601($self->due_date));
2217
2218    } else {
2219
2220       # if the due_date lands on a day when the location is closed
2221       return unless $copy and $circ->due_date;
2222
2223         #my $org = (ref $copy->circ_lib) ? $copy->circ_lib->id : $copy->circ_lib;
2224
2225         # due-date overlap should be determined by the location the item
2226         # is checked out from, not the owning or circ lib of the item
2227         my $org = $self->circ_lib;
2228
2229       $logger->info("circulator: circ searching for closed date overlap on lib $org".
2230             " with an item due date of ".$circ->due_date );
2231
2232       my $dateinfo = $U->storagereq(
2233          'open-ils.storage.actor.org_unit.closed_date.overlap', 
2234             $org, $circ->due_date );
2235
2236       if($dateinfo) {
2237          $logger->info("circulator: $dateinfo : circ due data / close date overlap found : due_date=".
2238             $circ->due_date." start=". $dateinfo->{start}.", end=".$dateinfo->{end});
2239
2240             # XXX make the behavior more dynamic
2241             # for now, we just push the due date to after the close date
2242             if ($shift_earlier) {
2243                 $circ->due_date($dateinfo->{start});
2244             } else {
2245                 $circ->due_date($dateinfo->{end});
2246             }
2247       }
2248    }
2249 }
2250
2251
2252
2253 sub create_due_date {
2254     my( $self, $duration, $date_ceiling, $force_date, $start_time ) = @_;
2255
2256     # if there is a raw time component (e.g. from postgres), 
2257     # turn it into an interval that interval_to_seconds can parse
2258     $duration =~ s/(\d{2}):(\d{2}):(\d{2})/$1 h $2 m $3 s/o;
2259
2260     # for now, use the server timezone.  TODO: use workstation org timezone
2261     my $due_date = DateTime->now(time_zone => 'local');
2262     $due_date = DateTime::Format::ISO8601->new->parse_datetime(cleanse_ISO8601($start_time)) if $start_time;
2263
2264     # add the circ duration
2265     $due_date->add(seconds => OpenSRF::Utils->interval_to_seconds($duration));
2266
2267     if($date_ceiling) {
2268         my $cdate = DateTime::Format::ISO8601->new->parse_datetime(cleanse_ISO8601($date_ceiling));
2269         if ($cdate > DateTime->now and ($cdate < $due_date or $U->is_true( $force_date ))) {
2270             $logger->info("circulator: overriding due date with date ceiling: $date_ceiling");
2271             $due_date = $cdate;
2272         }
2273     }
2274
2275     # return ISO8601 time with timezone
2276     return $due_date->strftime('%FT%T%z');
2277 }
2278
2279
2280
2281 sub make_precat_copy {
2282     my $self = shift;
2283     my $copy = $self->copy;
2284
2285    if($copy) {
2286         $logger->debug("circulator: Pre-cat copy already exists in checkout: ID=" . $copy->id);
2287
2288         $copy->editor($self->editor->requestor->id);
2289         $copy->edit_date('now');
2290         $copy->dummy_title($self->dummy_title || $copy->dummy_title || '');
2291         $copy->dummy_isbn($self->dummy_isbn || $copy->dummy_isbn || '');
2292         $copy->dummy_author($self->dummy_author || $copy->dummy_author || '');
2293         $copy->circ_modifier($self->circ_modifier || $copy->circ_modifier);
2294         $self->update_copy();
2295         return;
2296    }
2297
2298     $logger->info("circulator: Creating a new precataloged ".
2299         "copy in checkout with barcode " . $self->copy_barcode);
2300
2301     $copy = Fieldmapper::asset::copy->new;
2302     $copy->circ_lib($self->circ_lib);
2303     $copy->creator($self->editor->requestor->id);
2304     $copy->editor($self->editor->requestor->id);
2305     $copy->barcode($self->copy_barcode);
2306     $copy->call_number(OILS_PRECAT_CALL_NUMBER); 
2307     $copy->loan_duration(OILS_PRECAT_COPY_LOAN_DURATION);
2308     $copy->fine_level(OILS_PRECAT_COPY_FINE_LEVEL);
2309
2310     $copy->dummy_title($self->dummy_title || "");
2311     $copy->dummy_author($self->dummy_author || "");
2312     $copy->dummy_isbn($self->dummy_isbn || "");
2313     $copy->circ_modifier($self->circ_modifier);
2314
2315
2316     # See if we need to override the circ_lib for the copy with a configured circ_lib
2317     # Setting is shortname of the org unit
2318     my $precat_circ_lib = $U->ou_ancestor_setting_value(
2319         $self->circ_lib, 'circ.pre_cat_copy_circ_lib', $self->editor);
2320
2321     if($precat_circ_lib) {
2322         my $org = $self->editor->search_actor_org_unit({shortname => $precat_circ_lib})->[0];
2323
2324         if(!$org) {
2325             $self->bail_on_events($self->editor->event);
2326             return;
2327         }
2328
2329         $copy->circ_lib($org->id);
2330     }
2331
2332
2333     unless( $self->copy($self->editor->create_asset_copy($copy)) ) {
2334         $self->bail_out(1);
2335         $self->push_events($self->editor->event);
2336         return;
2337     }   
2338
2339     # this is a little bit of a hack, but we need to 
2340     # get the copy into the script runner
2341     $self->script_runner->insert("environment.copy", $copy, 1) if $self->script_runner;
2342 }
2343
2344
2345 sub checkout_noncat {
2346     my $self = shift;
2347
2348     my $circ;
2349     my $evt;
2350
2351    my $lib      = $self->noncat_circ_lib || $self->circ_lib;
2352    my $count    = $self->noncat_count || 1;
2353    my $cotime   = cleanse_ISO8601($self->checkout_time) || "";
2354
2355    $logger->info("circulator: circ creating $count noncat circs with checkout time $cotime");
2356
2357    for(1..$count) {
2358
2359       ( $circ, $evt ) = OpenILS::Application::Circ::NonCat::create_non_cat_circ(
2360          $self->editor->requestor->id, 
2361             $self->patron->id, 
2362             $lib, 
2363             $self->noncat_type, 
2364             $cotime,
2365             $self->editor );
2366
2367         if( $evt ) {
2368             $self->push_events($evt);
2369             $self->bail_out(1);
2370             return; 
2371         }
2372         $self->circ($circ);
2373    }
2374 }
2375
2376 # If a copy goes into transit and is then checked in before the transit checkin 
2377 # interval has expired, push an event onto the overridable events list.
2378 sub check_transit_checkin_interval {
2379     my $self = shift;
2380
2381     # only concerned with in-transit items
2382     return unless $U->copy_status($self->copy->status)->id == OILS_COPY_STATUS_IN_TRANSIT;
2383
2384     # no interval, no problem
2385     my $interval = $U->ou_ancestor_setting_value($self->circ_lib, 'circ.transit.min_checkin_interval');
2386     return unless $interval;
2387
2388     # capture the transit so we don't have to fetch it again later during checkin
2389     $self->transit(
2390         $self->editor->search_action_transit_copy(
2391             {target_copy => $self->copy->id, dest_recv_time => undef}
2392         )->[0]
2393     ); 
2394
2395     # transit from X to X for whatever reason has no min interval
2396     return if $self->transit->source == $self->transit->dest;
2397
2398     my $seconds = OpenSRF::Utils->interval_to_seconds($interval);
2399     my $t_start = DateTime::Format::ISO8601->new->parse_datetime(cleanse_ISO8601($self->transit->source_send_time));
2400     my $horizon = $t_start->add(seconds => $seconds);
2401
2402     # See if we are still within the transit checkin forbidden range
2403     $self->push_events(OpenILS::Event->new('TRANSIT_CHECKIN_INTERVAL_BLOCK')) 
2404         if $horizon > DateTime->now;
2405 }
2406
2407 # Retarget local holds at checkin
2408 sub checkin_retarget {
2409     my $self = shift;
2410     return unless $self->retarget_mode =~ m/retarget/; # Retargeting?
2411     return unless $self->is_checkin; # Renewals need not be checked
2412     return if $self->capture eq 'nocapture'; # Not capturing holds anyway? Move on.
2413     return if $self->is_precat; # No holds for precats
2414     return unless $self->circ_lib == $self->copy->circ_lib; # Item isn't "home"? Don't check.
2415     return unless $U->is_true($self->copy->holdable); # Not holdable, shouldn't capture holds.
2416     my $status = $U->copy_status($self->copy->status);
2417     return unless $U->is_true($status->holdable); # Current status not holdable means no hold will ever target the item
2418     # Specifically target items that are likely new (by status ID)
2419     return unless $status->id == OILS_COPY_STATUS_IN_PROCESS || $self->retarget_mode =~ m/\.all/;
2420     my $location = $self->copy->location;
2421     if(!ref($location)) {
2422         $location = $self->editor->retrieve_asset_copy_location($self->copy->location);
2423         $self->copy->location($location);
2424     }
2425     return unless $U->is_true($location->holdable); # Don't bother on non-holdable locations
2426
2427     # Fetch holds for the bib
2428     my ($result) = $holdcode->method_lookup('open-ils.circ.holds.retrieve_all_from_title')->run(
2429                     $self->editor->authtoken,
2430                     $self->title->id,
2431                     {
2432                         capture_time => undef, # No touching captured holds
2433                         frozen => 'f', # Don't bother with frozen holds
2434                         pickup_lib => $self->circ_lib # Only holds actually here
2435                     }); 
2436
2437     # Error? Skip the step.
2438     return if exists $result->{"ilsevent"};
2439
2440     # Assemble holds
2441     my $holds = [];
2442     foreach my $holdlist (keys %{$result}) {
2443         push @$holds, @{$result->{$holdlist}};
2444     }
2445
2446     return if scalar(@$holds) == 0; # No holds, no retargeting
2447
2448     # Check for parts on this copy
2449     my $parts = $self->editor->search_asset_copy_part_map({ target_copy => $self->copy->id });
2450     my %parts_hash = ();
2451     %parts_hash = map {$_->part, 1} @$parts if @$parts;
2452
2453     # Loop over holds in request-ish order
2454     # Stage 1: Get them into request-ish order
2455     # Also grab type and target for skipping low hanging ones
2456     $result = $self->editor->json_query({
2457         "select" => { "ahr" => ["id", "hold_type", "target"] },
2458         "from" => { "ahr" => { "au" => { "fkey" => "usr",  "join" => "pgt"} } },
2459         "where" => { "id" => $holds },
2460         "order_by" => [
2461             { "class" => "pgt", "field" => "hold_priority"},
2462             { "class" => "ahr", "field" => "cut_in_line", "direction" => "desc", "transform" => "coalesce", "params" => ['f']},
2463             { "class" => "ahr", "field" => "selection_depth", "direction" => "desc"},
2464             { "class" => "ahr", "field" => "request_time"}
2465         ]
2466     });
2467
2468     # Stage 2: Loop!
2469     if (ref $result eq "ARRAY" and scalar @$result) {
2470         foreach (@{$result}) {
2471             # Copy level, but not this copy?
2472             next if ($_->{hold_type} eq 'C' or $_->{hold_type} eq 'R' or $_->{hold_type} eq 'F'
2473                 and $_->{target} != $self->copy->id);
2474             # Volume level, but not this volume?
2475             next if ($_->{hold_type} eq 'V' and $_->{target} != $self->volume->id);
2476             if(@$parts) { # We have parts?
2477                 # Skip title holds
2478                 next if ($_->{hold_type} eq 'T');
2479                 # Skip part holds for parts not on this copy
2480                 next if ($_->{hold_type} eq 'P' and not $parts_hash{$_->{target}});
2481             } else {
2482                 # No parts, no part holds
2483                 next if ($_->{hold_type} eq 'P');
2484             }
2485             # So much for easy stuff, attempt a retarget!
2486             my $tresult = $U->storagereq('open-ils.storage.action.hold_request.copy_targeter', undef, $_->{id}, $self->copy->id);
2487             if(ref $tresult eq "ARRAY" and scalar @$tresult) {
2488                 last if(exists $tresult->[0]->{found_copy} and $tresult->[0]->{found_copy});
2489             }
2490         }
2491     }
2492 }
2493
2494 sub do_checkin {
2495     my $self = shift;
2496     $self->log_me("do_checkin()");
2497
2498     return $self->bail_on_events(
2499         OpenILS::Event->new('ASSET_COPY_NOT_FOUND')) 
2500         unless $self->copy;
2501
2502     $self->check_transit_checkin_interval;
2503     $self->checkin_retarget;
2504
2505     # the renew code and mk_env should have already found our circulation object
2506     unless( $self->circ ) {
2507
2508         my $circs = $self->editor->search_action_circulation(
2509             { target_copy => $self->copy->id, checkin_time => undef });
2510
2511         $self->circ($$circs[0]);
2512
2513         # for now, just warn if there are multiple open circs on a copy
2514         $logger->warn("circulator: we have ".scalar(@$circs).
2515             " open circs for copy " .$self->copy->id."!!") if @$circs > 1;
2516     }
2517
2518     # run the fine generator against this circ, if this circ is there
2519     $self->generate_fines_start if $self->circ;
2520
2521     if( $self->checkin_check_holds_shelf() ) {
2522         $self->bail_on_events(OpenILS::Event->new('NO_CHANGE'));
2523         $self->hold($U->fetch_open_hold_by_copy($self->copy->id));
2524         if($self->fake_hold_dest) {
2525             $self->hold->pickup_lib($self->circ_lib);
2526         }
2527         $self->checkin_flesh_events;
2528         return;
2529     }
2530
2531     unless( $self->is_renewal ) {
2532         return $self->bail_on_events($self->editor->event)
2533             unless $self->editor->allowed('COPY_CHECKIN');
2534     }
2535
2536     $self->push_events($self->check_copy_alert());
2537     $self->push_events($self->check_checkin_copy_status());
2538
2539     # if the circ is marked as 'claims returned', add the event to the list
2540     $self->push_events(OpenILS::Event->new('CIRC_CLAIMS_RETURNED'))
2541         if ($self->circ and $self->circ->stop_fines 
2542                 and $self->circ->stop_fines eq OILS_STOP_FINES_CLAIMSRETURNED);
2543
2544     $self->check_circ_deposit();
2545
2546     # handle the overridable events 
2547     $self->override_events unless $self->is_renewal;
2548     return if $self->bail_out;
2549     
2550     if( $self->copy and !$self->transit ) {
2551         $self->transit(
2552             $self->editor->search_action_transit_copy(
2553                 { target_copy => $self->copy->id, dest_recv_time => undef }
2554             )->[0]
2555         ); 
2556     }
2557
2558     if( $self->circ ) {
2559         $self->generate_fines_finish;
2560         $self->checkin_handle_circ;
2561         return if $self->bail_out;
2562         $self->checkin_changed(1);
2563
2564     } elsif( $self->transit ) {
2565         my $hold_transit = $self->process_received_transit;
2566         $self->checkin_changed(1);
2567
2568         if( $self->bail_out ) { 
2569             $self->checkin_flesh_events;
2570             return;
2571         }
2572         
2573         if( my $e = $self->check_checkin_copy_status() ) {
2574             # If the original copy status is special, alert the caller
2575             my $ev = $self->events;
2576             $self->events([$e]);
2577             $self->override_events;
2578             return if $self->bail_out;
2579             $self->events($ev);
2580         }
2581
2582         if( $hold_transit or 
2583                 $U->copy_status($self->copy->status)->id 
2584                     == OILS_COPY_STATUS_ON_HOLDS_SHELF ) {
2585
2586             my $hold;
2587             if( $hold_transit ) {
2588                $hold = $self->editor->retrieve_action_hold_request($hold_transit->hold);
2589             } else {
2590                    ($hold) = $U->fetch_open_hold_by_copy($self->copy->id);
2591             }
2592
2593             $self->hold($hold);
2594
2595             if( $hold and ( $hold->cancel_time or $hold->fulfillment_time ) ) { # this transited hold was cancelled or filled mid-transit
2596
2597                 $logger->info("circulator: we received a transit on a cancelled or filled hold " . $hold->id);
2598                 $self->reshelve_copy(1);
2599                 $self->cancelled_hold_transit(1);
2600                 $self->notify_hold(0); # don't notify for cancelled holds
2601                 $self->fake_hold_dest(0);
2602                 return if $self->bail_out;
2603
2604             } elsif ($hold and $hold->hold_type eq 'R') {
2605
2606                 $self->copy->status(OILS_COPY_STATUS_CATALOGING);
2607                 $self->notify_hold(0); # No need to notify
2608                 $self->fake_hold_dest(0);
2609                 $self->noop(1); # Don't try and capture for other holds/transits now
2610                 $self->update_copy();
2611                 $hold->fulfillment_time('now');
2612                 $self->bail_on_events($self->editor->event)
2613                     unless $self->editor->update_action_hold_request($hold);
2614
2615             } else {
2616
2617                 # hold transited to correct location
2618                 if($self->fake_hold_dest) {
2619                     $hold->pickup_lib($self->circ_lib);
2620                 }
2621                 $self->checkin_flesh_events;
2622                 return;
2623             }
2624         } 
2625
2626     } elsif( $U->copy_status($self->copy->status)->id == OILS_COPY_STATUS_IN_TRANSIT ) {
2627
2628         $logger->warn("circulator: we have a copy ".$self->copy->barcode.
2629             " that is in-transit, but there is no transit.. repairing");
2630         $self->reshelve_copy(1);
2631         return if $self->bail_out;
2632     }
2633
2634     if( $self->is_renewal ) {
2635         $self->finish_fines_and_voiding;
2636         return if $self->bail_out;
2637         $self->push_events(OpenILS::Event->new('SUCCESS'));
2638         return;
2639     }
2640
2641    # ------------------------------------------------------------------------------
2642    # Circulations and transits are now closed where necessary.  Now go on to see if
2643    # this copy can fulfill a hold or needs to be routed to a different location
2644    # ------------------------------------------------------------------------------
2645
2646     my $needed_for_something = 0; # formerly "needed_for_hold"
2647
2648     if(!$self->noop) { # /not/ a no-op checkin, capture for hold or put item into transit
2649
2650         if (!$self->remote_hold) {
2651             if ($self->use_booking) {
2652                 my $potential_hold = $self->hold_capture_is_possible;
2653                 my $potential_reservation = $self->reservation_capture_is_possible;
2654
2655                 if ($potential_hold and $potential_reservation) {
2656                     $logger->info("circulator: item could fulfill either hold or reservation");
2657                     $self->push_events(new OpenILS::Event(
2658                         "HOLD_RESERVATION_CONFLICT",
2659                         "hold" => $potential_hold,
2660                         "reservation" => $potential_reservation
2661                     ));
2662                     return if $self->bail_out;
2663                 } elsif ($potential_hold) {
2664                     $needed_for_something =
2665                         $self->attempt_checkin_hold_capture;
2666                 } elsif ($potential_reservation) {
2667                     $needed_for_something =
2668                         $self->attempt_checkin_reservation_capture;
2669                 }
2670             } else {
2671                 $needed_for_something = $self->attempt_checkin_hold_capture;
2672             }
2673         }
2674         return if $self->bail_out;
2675     
2676         unless($needed_for_something) {
2677             my $circ_lib = (ref $self->copy->circ_lib) ? 
2678                     $self->copy->circ_lib->id : $self->copy->circ_lib;
2679     
2680             if( $self->remote_hold ) {
2681                 $circ_lib = $self->remote_hold->pickup_lib;
2682                 $logger->warn("circulator: Copy ".$self->copy->barcode.
2683                     " is on a remote hold's shelf, sending to $circ_lib");
2684             }
2685     
2686             $logger->debug("circulator: circlib=$circ_lib, workstation=".$self->circ_lib);
2687
2688             my $suppress_transit = 0;
2689
2690             if( $circ_lib != $self->circ_lib and not ($self->hold_as_transit and $self->remote_hold) ) {
2691                 my $suppress_transit_source = $U->ou_ancestor_setting($self->circ_lib, 'circ.transit.suppress_non_hold');
2692                 if($suppress_transit_source && $suppress_transit_source->{value}) {
2693                     my $suppress_transit_dest = $U->ou_ancestor_setting($circ_lib, 'circ.transit.suppress_non_hold');
2694                     if($suppress_transit_dest && $suppress_transit_source->{value} eq $suppress_transit_dest->{value}) {
2695                         $logger->info("circulator: copy is within transit suppress group: ".$self->copy->barcode." ".$suppress_transit_source->{value});
2696                         $suppress_transit = 1;
2697                     }
2698                 }
2699             }
2700  
2701             if( $suppress_transit or ( $circ_lib == $self->circ_lib and not ($self->hold_as_transit and $self->remote_hold) ) ) {
2702                 # copy is where it needs to be, either for hold or reshelving
2703     
2704                 $self->checkin_handle_precat();
2705                 return if $self->bail_out;
2706     
2707             } else {
2708                 # copy needs to transit "home", or stick here if it's a floating copy
2709                 my $can_float = 0;
2710                 if ($self->copy->floating && ($self->manual_float || !$U->is_true($self->copy->floating->manual)) && !$self->remote_hold) { # copy is potentially floating?
2711                     my $res = $self->editor->json_query(
2712                         {   from => [
2713                                 'evergreen.can_float',
2714                                 $self->copy->floating->id,
2715                                 $self->copy->circ_lib,
2716                                 $self->circ_lib
2717                             ]
2718                         }
2719                     );
2720                     $can_float = $U->is_true($res->[0]->{'evergreen.can_float'}) if $res; 
2721                 }
2722                 if ($can_float) { # Yep, floating, stick here
2723                     $self->checkin_changed(1);
2724                     $self->copy->circ_lib( $self->circ_lib );
2725                     $self->update_copy;
2726                 } else {
2727                     my $bc = $self->copy->barcode;
2728                     $logger->info("circulator: copy $bc at the wrong location, sending to $circ_lib");
2729                     $self->checkin_build_copy_transit($circ_lib);
2730                     return if $self->bail_out;
2731                     $self->push_events(OpenILS::Event->new('ROUTE_ITEM', org => $circ_lib));
2732                 }
2733             }
2734         }
2735     } else { # no-op checkin
2736         if ($U->is_true( $self->copy->floating )) { # XXX floating items still stick where they are even with no-op checkin?
2737             $self->checkin_changed(1);
2738             $self->copy->circ_lib( $self->circ_lib );
2739             $self->update_copy;
2740         }
2741     }
2742
2743     if($self->claims_never_checked_out and 
2744             $U->ou_ancestor_setting_value($self->circ->circ_lib, 'circ.claim_never_checked_out.mark_missing')) {
2745
2746         # the item was not supposed to be checked out to the user and should now be marked as missing
2747         $self->copy->status(OILS_COPY_STATUS_MISSING);
2748         $self->update_copy;
2749
2750     } else {
2751         $self->reshelve_copy unless $needed_for_something;
2752     }
2753
2754     return if $self->bail_out;
2755
2756     unless($self->checkin_changed) {
2757
2758         $self->push_events(OpenILS::Event->new('NO_CHANGE'));
2759         my $stat = $U->copy_status($self->copy->status)->id;
2760
2761         $self->hold($U->fetch_open_hold_by_copy($self->copy->id))
2762          if( $stat == OILS_COPY_STATUS_ON_HOLDS_SHELF );
2763         $self->bail_out(1); # no need to commit anything
2764
2765     } else {
2766
2767         $self->push_events(OpenILS::Event->new('SUCCESS')) 
2768             unless @{$self->events};
2769     }
2770
2771     $self->finish_fines_and_voiding;
2772
2773     OpenILS::Utils::Penalty->calculate_penalties(
2774         $self->editor, $self->patron->id, $self->circ_lib) if $self->patron;
2775
2776     $self->checkin_flesh_events;
2777     return;
2778 }
2779
2780 sub finish_fines_and_voiding {
2781     my $self = shift;
2782     return unless $self->circ;
2783
2784     # gather any updates to the circ after fine generation, if there was a circ
2785     $self->generate_fines_finish;
2786
2787     return unless $self->backdate or $self->void_overdues;
2788
2789     # void overdues after fine generation to prevent concurrent DB access to overdue billings
2790     my $note = 'System: Amnesty Checkin' if $self->void_overdues;
2791
2792     my $evt = OpenILS::Application::Circ::CircCommon->void_overdues(
2793         $self->editor, $self->circ, $self->backdate, $note);
2794
2795     return $self->bail_on_events($evt) if $evt;
2796
2797     # Make sure the circ is open or closed as necessary.
2798     $evt = $U->check_open_xact($self->editor, $self->circ->id);
2799     return $self->bail_on_events($evt) if $evt;
2800
2801     return undef;
2802 }
2803
2804
2805 # if a deposit was payed for this item, push the event
2806 sub check_circ_deposit {
2807     my $self = shift;
2808     return unless $self->circ;
2809     my $deposit = $self->editor->search_money_billing(
2810         {   btype => 5, 
2811             xact => $self->circ->id, 
2812             voided => 'f'
2813         }, {idlist => 1})->[0];
2814
2815     $self->push_events(OpenILS::Event->new(
2816         'ITEM_DEPOSIT_PAID', payload => $deposit)) if $deposit;
2817 }
2818
2819 sub reshelve_copy {
2820    my $self    = shift;
2821    my $force   = $self->force || shift;
2822    my $copy    = $self->copy;
2823
2824    my $stat = $U->copy_status($copy->status)->id;
2825
2826    if($force || (
2827       $stat != OILS_COPY_STATUS_ON_HOLDS_SHELF and
2828       $stat != OILS_COPY_STATUS_CATALOGING and
2829       $stat != OILS_COPY_STATUS_IN_TRANSIT and
2830       $stat != OILS_COPY_STATUS_RESHELVING  )) {
2831
2832         $copy->status( OILS_COPY_STATUS_RESHELVING );
2833             $self->update_copy;
2834             $self->checkin_changed(1);
2835     }
2836 }
2837
2838
2839 # Returns true if the item is at the current location
2840 # because it was transited there for a hold and the 
2841 # hold has not been fulfilled
2842 sub checkin_check_holds_shelf {
2843     my $self = shift;
2844     return 0 unless $self->copy;
2845
2846     return 0 unless 
2847         $U->copy_status($self->copy->status)->id ==
2848             OILS_COPY_STATUS_ON_HOLDS_SHELF;
2849
2850     # Attempt to clear shelf expired holds for this copy
2851     $holdcode->method_lookup('open-ils.circ.hold.clear_shelf.process')->run($self->editor->authtoken, $self->circ_lib, $self->copy->id)
2852         if($self->clear_expired);
2853
2854     # find the hold that put us on the holds shelf
2855     my $holds = $self->editor->search_action_hold_request(
2856         { 
2857             current_copy => $self->copy->id,
2858             capture_time => { '!=' => undef },
2859             fulfillment_time => undef,
2860             cancel_time => undef,
2861         }
2862     );
2863
2864     unless(@$holds) {
2865         $logger->warn("circulator: copy is on-holds-shelf, but there is no hold - reshelving");
2866         $self->reshelve_copy(1);
2867         return 0;
2868     }
2869
2870     my $hold = $$holds[0];
2871
2872     $logger->info("circulator: we found a captured, un-fulfilled hold [".
2873         $hold->id. "] for copy ".$self->copy->barcode);
2874
2875     if( $hold->pickup_lib != $self->circ_lib and not $self->hold_as_transit ) {
2876         my $suppress_transit_circ = $U->ou_ancestor_setting($self->circ_lib, 'circ.transit.suppress_hold');
2877         if($suppress_transit_circ && $suppress_transit_circ->{value}) {
2878             my $suppress_transit_pickup = $U->ou_ancestor_setting($hold->pickup_lib, 'circ.transit.suppress_hold');
2879             if($suppress_transit_pickup && $suppress_transit_circ->{value} eq $suppress_transit_pickup->{value}) {
2880                 $logger->info("circulator: hold is within hold transit suppress group .. we're done: ".$self->copy->barcode." ".$suppress_transit_circ->{value});
2881                 $self->fake_hold_dest(1);
2882                 return 1;
2883             }
2884         }
2885     }
2886
2887     if( $hold->pickup_lib == $self->circ_lib and not $self->hold_as_transit ) {
2888         $logger->info("circulator: hold is for here .. we're done: ".$self->copy->barcode);
2889         return 1;
2890     }
2891
2892     $logger->info("circulator: hold is not for here..");
2893     $self->remote_hold($hold);
2894     return 0;
2895 }
2896
2897
2898 sub checkin_handle_precat {
2899     my $self    = shift;
2900    my $copy    = $self->copy;
2901
2902    if( $self->is_precat and ($copy->status != OILS_COPY_STATUS_CATALOGING) ) {
2903         $copy->status(OILS_COPY_STATUS_CATALOGING);
2904         $self->update_copy();
2905         $self->checkin_changed(1);
2906         $self->push_events(OpenILS::Event->new('ITEM_NOT_CATALOGED'));
2907    }
2908 }
2909
2910
2911 sub checkin_build_copy_transit {
2912     my $self            = shift;
2913     my $dest            = shift;
2914     my $copy       = $self->copy;
2915     my $transit    = Fieldmapper::action::transit_copy->new;
2916
2917     # if we are transiting an item to the shelf shelf, it's a hold transit
2918     if (my $hold = $self->remote_hold) {
2919         $transit = Fieldmapper::action::hold_transit_copy->new;
2920         $transit->hold($hold->id);
2921
2922         # the item is going into transit, remove any shelf-iness
2923         if ($hold->current_shelf_lib or $hold->shelf_time) {
2924             $hold->clear_current_shelf_lib;
2925             $hold->clear_shelf_time;
2926             return $self->bail_on_events($self->editor->event)
2927                 unless $self->editor->update_action_hold_request($hold);
2928         }
2929     }
2930
2931     #$dest  ||= (ref($copy->circ_lib)) ? $copy->circ_lib->id : $copy->circ_lib;
2932     $logger->info("circulator: transiting copy to $dest");
2933
2934     $transit->source($self->circ_lib);
2935     $transit->dest($dest);
2936     $transit->target_copy($copy->id);
2937     $transit->source_send_time('now');
2938     $transit->copy_status( $U->copy_status($copy->status)->id );
2939
2940     $logger->debug("circulator: setting copy status on transit: ".$transit->copy_status);
2941
2942     if ($self->remote_hold) {
2943         return $self->bail_on_events($self->editor->event)
2944             unless $self->editor->create_action_hold_transit_copy($transit);
2945     } else {
2946         return $self->bail_on_events($self->editor->event)
2947             unless $self->editor->create_action_transit_copy($transit);
2948     }
2949
2950     # ensure the transit is returned to the caller
2951     $self->transit($transit);
2952
2953     $copy->status(OILS_COPY_STATUS_IN_TRANSIT);
2954     $self->update_copy;
2955     $self->checkin_changed(1);
2956 }
2957
2958
2959 sub hold_capture_is_possible {
2960     my $self = shift;
2961     my $copy = $self->copy;
2962
2963     # we've been explicitly told not to capture any holds
2964     return 0 if $self->capture eq 'nocapture';
2965
2966     # See if this copy can fulfill any holds
2967     my $hold = $holdcode->find_nearest_permitted_hold(
2968         $self->editor, $copy, $self->editor->requestor, 1 # check_only
2969     );
2970     return undef if ref $hold eq "HASH" and
2971         $hold->{"textcode"} eq "ACTION_HOLD_REQUEST_NOT_FOUND";
2972     return $hold;
2973 }
2974
2975 sub reservation_capture_is_possible {
2976     my $self = shift;
2977     my $copy = $self->copy;
2978
2979     # we've been explicitly told not to capture any holds
2980     return 0 if $self->capture eq 'nocapture';
2981
2982     my $booking_ses = OpenSRF::AppSession->connect("open-ils.booking");
2983     my $resv = $booking_ses->request(
2984         "open-ils.booking.reservations.could_capture",
2985         $self->editor->authtoken, $copy->barcode
2986     )->gather(1);
2987     $booking_ses->disconnect;
2988     if (ref($resv) eq "HASH" and exists $resv->{"textcode"}) {
2989         $self->push_events($resv);
2990     } else {
2991         return $resv;
2992     }
2993 }
2994
2995 # returns true if the item was used (or may potentially be used 
2996 # in subsequent calls) to capture a hold.
2997 sub attempt_checkin_hold_capture {
2998     my $self = shift;
2999     my $copy = $self->copy;
3000
3001     # we've been explicitly told not to capture any holds
3002     return 0 if $self->capture eq 'nocapture';
3003
3004     # See if this copy can fulfill any holds
3005     my ($hold, undef, $retarget) = $holdcode->find_nearest_permitted_hold( 
3006         $self->editor, $copy, $self->editor->requestor );
3007
3008     if(!$hold) {
3009         $logger->debug("circulator: no potential permitted".
3010             "holds found for copy ".$copy->barcode);
3011         return 0;
3012     }
3013
3014     if($self->capture ne 'capture') {
3015         # see if this item is in a hold-capture-delay location
3016         my $location = $self->copy->location;
3017         if(!ref($location)) {
3018             $location = $self->editor->retrieve_asset_copy_location($self->copy->location);
3019             $self->copy->location($location);
3020         }
3021         if($U->is_true($location->hold_verify)) {
3022             $self->bail_on_events(
3023                 OpenILS::Event->new('HOLD_CAPTURE_DELAYED', copy_location => $location));
3024             return 1;
3025         }
3026     }
3027
3028     $self->retarget($retarget);
3029
3030     my $suppress_transit = 0;
3031     if( $hold->pickup_lib != $self->circ_lib and not $self->hold_as_transit ) {
3032         my $suppress_transit_circ = $U->ou_ancestor_setting($self->circ_lib, 'circ.transit.suppress_hold');
3033         if($suppress_transit_circ && $suppress_transit_circ->{value}) {
3034             my $suppress_transit_pickup = $U->ou_ancestor_setting($hold->pickup_lib, 'circ.transit.suppress_hold');
3035             if($suppress_transit_pickup && $suppress_transit_circ->{value} eq $suppress_transit_pickup->{value}) {
3036                 $suppress_transit = 1;
3037                 $hold->pickup_lib($self->circ_lib);
3038             }
3039         }
3040     }
3041
3042     $logger->info("circulator: found permitted hold ".$hold->id." for copy, capturing...");
3043
3044     $hold->current_copy($copy->id);
3045     $hold->capture_time('now');
3046     $self->put_hold_on_shelf($hold) 
3047         if ($suppress_transit || ($hold->pickup_lib == $self->circ_lib and not $self->hold_as_transit) );
3048
3049     # prevent DB errors caused by fetching 
3050     # holds from storage, and updating through cstore
3051     $hold->clear_fulfillment_time;
3052     $hold->clear_fulfillment_staff;
3053     $hold->clear_fulfillment_lib;
3054     $hold->clear_expire_time; 
3055     $hold->clear_cancel_time;
3056     $hold->clear_prev_check_time unless $hold->prev_check_time;
3057
3058     $self->bail_on_events($self->editor->event)
3059         unless $self->editor->update_action_hold_request($hold);
3060     $self->hold($hold);
3061     $self->checkin_changed(1);
3062
3063     return 0 if $self->bail_out;
3064
3065     if( $suppress_transit or ( $hold->pickup_lib == $self->circ_lib && not $self->hold_as_transit ) ) {
3066
3067         if ($hold->hold_type eq 'R') {
3068             $copy->status(OILS_COPY_STATUS_CATALOGING);
3069             $hold->fulfillment_time('now');
3070             $self->noop(1); # Block other transit/hold checks
3071             $self->bail_on_events($self->editor->event)
3072                 unless $self->editor->update_action_hold_request($hold);
3073         } else {
3074             # This hold was captured in the correct location
3075             $copy->status(OILS_COPY_STATUS_ON_HOLDS_SHELF);
3076             $self->push_events(OpenILS::Event->new('SUCCESS'));
3077
3078             #$self->do_hold_notify($hold->id);
3079             $self->notify_hold($hold->id);
3080         }
3081
3082     } else {
3083     
3084         # Hold needs to be picked up elsewhere.  Build a hold
3085         # transit and route the item.
3086         $self->checkin_build_hold_transit();
3087         $copy->status(OILS_COPY_STATUS_IN_TRANSIT);
3088         return 0 if $self->bail_out;
3089         $self->push_events(OpenILS::Event->new('ROUTE_ITEM', org => $hold->pickup_lib));
3090     }
3091
3092     # make sure we save the copy status
3093     $self->update_copy;
3094     return 0 if $copy->status == OILS_COPY_STATUS_CATALOGING;
3095     return 1;
3096 }
3097
3098 sub attempt_checkin_reservation_capture {
3099     my $self = shift;
3100     my $copy = $self->copy;
3101
3102     # we've been explicitly told not to capture any holds
3103     return 0 if $self->capture eq 'nocapture';
3104
3105     my $booking_ses = OpenSRF::AppSession->connect("open-ils.booking");
3106     my $evt = $booking_ses->request(
3107         "open-ils.booking.resources.capture_for_reservation",
3108         $self->editor->authtoken,
3109         $copy->barcode,
3110         1 # don't update copy - we probably have it locked
3111     )->gather(1);
3112     $booking_ses->disconnect;
3113
3114     if (ref($evt) ne "HASH" or not exists $evt->{"textcode"}) {
3115         $logger->warn(
3116             "open-ils.booking.resources.capture_for_reservation " .
3117             "didn't return an event!"
3118         );
3119     } else {
3120         if (
3121             $evt->{"textcode"} eq "RESERVATION_NOT_FOUND" and
3122             $evt->{"payload"}->{"fail_cause"} eq "not-transferable"
3123         ) {
3124             # not-transferable is an error event we'll pass on the user
3125             $logger->warn("reservation capture attempted against non-transferable item");
3126             $self->push_events($evt);
3127             return 0;
3128         } elsif ($evt->{"textcode"} eq "SUCCESS") {
3129             # Re-retrieve copy as reservation capture may have changed
3130             # its status and whatnot.
3131             $logger->info(
3132                 "circulator: booking capture win on copy " . $self->copy->id
3133             );
3134             if (my $new_copy_status = $evt->{"payload"}->{"new_copy_status"}) {
3135                 $logger->info(
3136                     "circulator: changing copy " . $self->copy->id .
3137                     "'s status from " . $self->copy->status . " to " .
3138                     $new_copy_status
3139                 );
3140                 $self->copy->status($new_copy_status);
3141                 $self->update_copy;
3142             }
3143             $self->reservation($evt->{"payload"}->{"reservation"});
3144
3145             if (exists $evt->{"payload"}->{"transit"}) {
3146                 $self->push_events(
3147                     new OpenILS::Event(
3148                         "ROUTE_ITEM",
3149                         "org" => $evt->{"payload"}->{"transit"}->dest
3150                     )
3151                 );
3152             }
3153             $self->checkin_changed(1);
3154             return 1;
3155         }
3156     }
3157     # other results are treated as "nothing to capture"
3158     return 0;
3159 }
3160
3161 sub do_hold_notify {
3162     my( $self, $holdid ) = @_;
3163
3164     my $e = new_editor(xact => 1);
3165     my $hold = $e->retrieve_action_hold_request($holdid) or return $e->die_event;
3166     $e->rollback;
3167     my $ses = OpenSRF::AppSession->create('open-ils.trigger');
3168     $ses->request('open-ils.trigger.event.autocreate', 'hold.available', $hold, $hold->pickup_lib);
3169
3170     $logger->info("circulator: running delayed hold notify process");
3171
3172 #   my $notifier = OpenILS::Application::Circ::HoldNotify->new(
3173 #       hold_id => $holdid, editor => new_editor(requestor=>$self->editor->requestor));
3174
3175     my $notifier = OpenILS::Application::Circ::HoldNotify->new(
3176         hold_id => $holdid, requestor => $self->editor->requestor);
3177
3178     $logger->debug("circulator: built hold notifier");
3179
3180     if(!$notifier->event) {
3181
3182         $logger->info("circulator: attempt at sending hold notification for hold $holdid");
3183
3184         my $stat = $notifier->send_email_notify;
3185         if( $stat == '1' ) {
3186             $logger->info("circulator: hold notify succeeded for hold $holdid");
3187             return;
3188         } 
3189
3190         $logger->debug("circulator:  * hold notify cancelled or failed for hold $holdid");
3191
3192     } else {
3193         $logger->info("circulator: Not sending hold notification since the patron has no email address");
3194     }
3195 }
3196
3197 sub retarget_holds {
3198     my $self = shift;
3199     $logger->info("circulator: retargeting holds @{$self->retarget} after opportunistic capture");
3200     my $ses = OpenSRF::AppSession->create('open-ils.storage');
3201     $ses->request('open-ils.storage.action.hold_request.copy_targeter', undef, $self->retarget);
3202     # no reason to wait for the return value
3203     return;
3204 }
3205
3206 sub checkin_build_hold_transit {
3207     my $self = shift;
3208
3209    my $copy = $self->copy;
3210    my $hold = $self->hold;
3211    my $trans = Fieldmapper::action::hold_transit_copy->new;
3212
3213     $logger->debug("circulator: building hold transit for ".$copy->barcode);
3214
3215    $trans->hold($hold->id);
3216    $trans->source($self->circ_lib);
3217    $trans->dest($hold->pickup_lib);
3218    $trans->source_send_time("now");
3219    $trans->target_copy($copy->id);
3220
3221     # when the copy gets to its destination, it will recover
3222     # this status - put it onto the holds shelf
3223    $trans->copy_status(OILS_COPY_STATUS_ON_HOLDS_SHELF);
3224
3225     return $self->bail_on_events($self->editor->event)
3226         unless $self->editor->create_action_hold_transit_copy($trans);
3227 }
3228
3229
3230
3231 sub process_received_transit {
3232     my $self = shift;
3233     my $copy = $self->copy;
3234     my $copyid = $self->copy->id;
3235
3236     my $status_name = $U->copy_status($copy->status)->name;
3237     $logger->debug("circulator: attempting transit receive on ".
3238         "copy $copyid. Copy status is $status_name");
3239
3240     my $transit = $self->transit;
3241
3242     # Check if we are in a transit suppress range
3243     my $suppress_transit = 0;
3244     if ( $transit->dest != $self->circ_lib and not ( $self->hold_as_transit and $transit->copy_status == OILS_COPY_STATUS_ON_HOLDS_SHELF ) ) {
3245         my $suppress_setting = ($transit->copy_status == OILS_COPY_STATUS_ON_HOLDS_SHELF ?  'circ.transit.suppress_hold' : 'circ.transit.suppress_non_hold');
3246         my $suppress_transit_circ = $U->ou_ancestor_setting($self->circ_lib, $suppress_setting);
3247         if($suppress_transit_circ && $suppress_transit_circ->{value}) {
3248             my $suppress_transit_dest = $U->ou_ancestor_setting($transit->dest, $suppress_setting);
3249             if($suppress_transit_dest && $suppress_transit_dest->{value} eq $suppress_transit_circ->{value}) {
3250                 $suppress_transit = 1;
3251                 $self->fake_hold_dest(1) if $transit->copy_status == OILS_COPY_STATUS_ON_HOLDS_SHELF;
3252             }
3253         }
3254     }
3255     if( not $suppress_transit and ( $transit->dest != $self->circ_lib or ($self->hold_as_transit && $transit->copy_status == OILS_COPY_STATUS_ON_HOLDS_SHELF) ) ) {
3256         # - this item is in-transit to a different location
3257         # - Or we are capturing holds as transits, so why create a new transit?
3258
3259         my $tid = $transit->id; 
3260         my $loc = $self->circ_lib;
3261         my $dest = $transit->dest;
3262
3263         $logger->info("circulator: Fowarding transit on copy which is destined ".
3264             "for a different location. transit=$tid, copy=$copyid, current ".
3265             "location=$loc, destination location=$dest");
3266
3267         my $evt = OpenILS::Event->new('ROUTE_ITEM', org => $dest, payload => {});
3268
3269         # grab the associated hold object if available
3270         my $ht = $self->editor->retrieve_action_hold_transit_copy($tid);
3271         $self->hold($self->editor->retrieve_action_hold_request($ht->hold)) if $ht;
3272
3273         return $self->bail_on_events($evt);
3274     }
3275
3276     # The transit is received, set the receive time
3277     $transit->dest_recv_time('now');
3278     $self->bail_on_events($self->editor->event)
3279         unless $self->editor->update_action_transit_copy($transit);
3280
3281     my $hold_transit = $self->editor->retrieve_action_hold_transit_copy($transit->id);
3282
3283     $logger->info("circulator: Recovering original copy status in transit: ".$transit->copy_status);
3284     $copy->status( $transit->copy_status );
3285     $self->update_copy();
3286     return if $self->bail_out;
3287
3288     my $ishold = 0;
3289     if($hold_transit) { 
3290         my $hold = $self->editor->retrieve_action_hold_request($hold_transit->hold);
3291
3292         if ($hold) {
3293             # hold has arrived at destination, set shelf time
3294             $self->put_hold_on_shelf($hold);
3295             $self->bail_on_events($self->editor->event)
3296                 unless $self->editor->update_action_hold_request($hold);
3297             return if $self->bail_out;
3298
3299             $self->notify_hold($hold_transit->hold);
3300             $ishold = 1;
3301         } else {
3302             $hold_transit = undef;
3303             $self->cancelled_hold_transit(1);
3304             $self->reshelve_copy(1);
3305             $self->fake_hold_dest(0);
3306         }
3307     }
3308
3309     $self->push_events( 
3310         OpenILS::Event->new(
3311         'SUCCESS', 
3312         ishold => $ishold,
3313       payload => { transit => $transit, holdtransit => $hold_transit } ));
3314
3315     return $hold_transit;
3316 }
3317
3318
3319 # ------------------------------------------------------------------
3320 # Sets the shelf_time and shelf_expire_time for a newly shelved hold
3321 # ------------------------------------------------------------------
3322 sub put_hold_on_shelf {
3323     my($self, $hold) = @_;
3324     $hold->shelf_time('now');
3325     $hold->current_shelf_lib($self->circ_lib);
3326     $holdcode->set_hold_shelf_expire_time($hold, $self->editor);
3327     return undef;
3328 }
3329
3330
3331
3332 sub generate_fines {
3333    my $self = shift;
3334    my $reservation = shift;
3335
3336    $self->generate_fines_start($reservation);
3337    $self->generate_fines_finish($reservation);
3338
3339    return undef;
3340 }
3341
3342 sub generate_fines_start {
3343    my $self = shift;
3344    my $reservation = shift;
3345    my $dt_parser = DateTime::Format::ISO8601->new;
3346
3347    my $obj = $reservation ? $self->reservation : $self->circ;
3348
3349    # If we have a grace period
3350    if($obj->can('grace_period')) {
3351       # Parse out the due date
3352       my $due_date = $dt_parser->parse_datetime( cleanse_ISO8601($obj->due_date) );
3353       # Add the grace period to the due date
3354       $due_date->add(seconds => OpenSRF::Utils->interval_to_seconds($obj->grace_period));
3355       # Don't generate fines on circs still in grace period
3356       return undef if ($due_date > DateTime->now);
3357    }
3358
3359    if (!exists($self->{_gen_fines_req})) {
3360       $self->{_gen_fines_req} = OpenSRF::AppSession->create('open-ils.storage') 
3361           ->request(
3362              'open-ils.storage.action.circulation.overdue.generate_fines',
3363              $obj->id
3364           );
3365    }
3366
3367    return undef;
3368 }
3369
3370 sub generate_fines_finish {
3371    my $self = shift;
3372    my $reservation = shift;
3373
3374    return undef unless $self->{_gen_fines_req};
3375
3376    my $id = $reservation ? $self->reservation->id : $self->circ->id;
3377
3378    $self->{_gen_fines_req}->wait_complete;
3379    delete($self->{_gen_fines_req});
3380
3381    # refresh the circ in case the fine generator set the stop_fines field
3382    $self->reservation($self->editor->retrieve_booking_reservation($id)) if $reservation;
3383    $self->circ($self->editor->retrieve_action_circulation($id)) if !$reservation;
3384
3385    return undef;
3386 }
3387
3388 sub checkin_handle_circ {
3389    my $self = shift;
3390    my $circ = $self->circ;
3391    my $copy = $self->copy;
3392    my $evt;
3393    my $obt;
3394
3395    $self->backdate($circ->xact_start) if $self->claims_never_checked_out;
3396
3397    # backdate the circ if necessary
3398    if($self->backdate) {
3399         my $evt = $self->checkin_handle_backdate;
3400         return $self->bail_on_events($evt) if $evt;
3401    }
3402
3403    if(!$circ->stop_fines) {
3404       $circ->stop_fines(OILS_STOP_FINES_CHECKIN);
3405       $circ->stop_fines(OILS_STOP_FINES_RENEW) if $self->is_renewal;
3406       $circ->stop_fines(OILS_STOP_FINES_CLAIMS_NEVERCHECKEDOUT) if $self->claims_never_checked_out;
3407       $circ->stop_fines_time('now');
3408       $circ->stop_fines_time($self->backdate) if $self->backdate;
3409    }
3410
3411     # Set the checkin vars since we have the item
3412     $circ->checkin_time( ($self->backdate) ? $self->backdate : 'now' );
3413
3414     # capture the true scan time for back-dated checkins
3415     $circ->checkin_scan_time('now');
3416
3417     $circ->checkin_staff($self->editor->requestor->id);
3418     $circ->checkin_lib($self->circ_lib);
3419     $circ->checkin_workstation($self->editor->requestor->wsid);
3420
3421     my $circ_lib = (ref $self->copy->circ_lib) ?  
3422         $self->copy->circ_lib->id : $self->copy->circ_lib;
3423     my $stat = $U->copy_status($self->copy->status)->id;
3424
3425     if ($stat == OILS_COPY_STATUS_LOST || $stat == OILS_COPY_STATUS_LOST_AND_PAID) {
3426         # we will now handle lost fines, but the copy will retain its 'lost'
3427         # status if it needs to transit home unless lost_immediately_available
3428         # is true
3429         #
3430         # if we decide to also delay fine handling until the item arrives home,
3431         # we will need to call lost fine handling code both when checking items
3432         # in and also when receiving transits
3433         $self->checkin_handle_lost($circ_lib);
3434     } elsif ($stat == OILS_COPY_STATUS_LONG_OVERDUE) {
3435         # same process as above.
3436         $self->checkin_handle_long_overdue($circ_lib);
3437     } elsif ($circ_lib != $self->circ_lib and $stat == OILS_COPY_STATUS_MISSING) {
3438         $logger->info("circulator: not updating copy status on checkin because copy is missing");
3439     } else {
3440         $self->copy->status($U->copy_status(OILS_COPY_STATUS_RESHELVING));
3441         $self->update_copy;
3442     }
3443
3444
3445     # see if there are any fines owed on this circ.  if not, close it
3446     ($obt) = $U->fetch_mbts($circ->id, $self->editor);
3447     $circ->xact_finish('now') if( $obt and $obt->balance_owed == 0 );
3448
3449     $logger->debug("circulator: ".$obt->balance_owed." is owed on this circulation");
3450
3451     return $self->bail_on_events($self->editor->event)
3452         unless $self->editor->update_action_circulation($circ);
3453
3454     return undef;
3455 }
3456
3457 # ------------------------------------------------------------------
3458 # See if we need to void billings, etc. for lost checkin
3459 # ------------------------------------------------------------------
3460 sub checkin_handle_lost {
3461     my $self = shift;
3462     my $circ_lib = shift;
3463
3464     my $max_return = $U->ou_ancestor_setting_value($circ_lib, 
3465         OILS_SETTING_MAX_ACCEPT_RETURN_OF_LOST, $self->editor) || 0;
3466
3467     return $self->checkin_handle_lost_or_longoverdue(
3468         circ_lib => $circ_lib,
3469         max_return => $max_return,
3470         ous_void_item_cost => OILS_SETTING_VOID_LOST_ON_CHECKIN,
3471         ous_void_proc_fee => OILS_SETTING_VOID_LOST_PROCESS_FEE_ON_CHECKIN,
3472         ous_restore_overdue => OILS_SETTING_RESTORE_OVERDUE_ON_LOST_RETURN,
3473         ous_immediately_available => OILS_SETTING_LOST_IMMEDIATELY_AVAILABLE,
3474         ous_use_last_activity => undef, # not supported for LOST checkin
3475         void_cost_btype => 3, 
3476         void_fee_btype => 4 
3477     );
3478 }
3479
3480 # ------------------------------------------------------------------
3481 # See if we need to void billings, etc. for long-overdue checkin
3482 # note: not using constants below since they serve little purpose 
3483 # for single-use strings that are descriptive in their own right 
3484 # and mostly just complicate debugging.
3485 # ------------------------------------------------------------------
3486 sub checkin_handle_long_overdue {
3487     my $self = shift;
3488     my $circ_lib = shift;
3489
3490     $logger->info("circulator: processing long-overdue checkin...");
3491
3492     my $max_return = $U->ou_ancestor_setting_value($circ_lib, 
3493         'circ.max_accept_return_of_longoverdue', $self->editor) || 0;
3494
3495     return $self->checkin_handle_lost_or_longoverdue(
3496         circ_lib => $circ_lib,
3497         max_return => $max_return,
3498         is_longoverdue => 1,
3499         ous_void_item_cost => 'circ.void_longoverdue_on_checkin',