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