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 },
 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         $self->circ_matrix_matchpoint->hard_due_date($self->editor->retrieve_config_hard_due_date($results->[0]->{hard_due_date}));
1058         # Grab the *last* response for limit_groups, where it is more likely to be filled
1059         $self->limit_groups($results->[-1]->{limit_groups});
1060     }
1061
1062     return $self->matrix_test_result($results);
1063 }
1064
1065 # ---------------------------------------------------------------------
1066 # given a use and copy, this will calculate the circulation policy
1067 # parameters.  Only works with in-db circ.
1068 # ---------------------------------------------------------------------
1069 sub do_inspect {
1070     my $self = shift;
1071
1072     return OpenILS::Event->new('ASSET_COPY_NOT_FOUND') unless $self->copy;
1073
1074     $self->run_indb_circ_test;
1075
1076     my $results = {
1077         circ_test_success => $self->circ_test_success,
1078         failure_events => [],
1079         failure_codes => [],
1080         matchpoint => $self->circ_matrix_matchpoint
1081     };
1082
1083     unless($self->circ_test_success) {
1084         $results->{"failure_codes"} = [ $self->matrix_test_result_codes ];
1085         $results->{"failure_events"} = [ $self->matrix_test_result_events ];
1086     }
1087
1088     if($self->circ_matrix_matchpoint) {
1089         my $duration_rule = $self->circ_matrix_matchpoint->duration_rule;
1090         my $recurring_fine_rule = $self->circ_matrix_matchpoint->recurring_fine_rule;
1091         my $max_fine_rule = $self->circ_matrix_matchpoint->max_fine_rule;
1092         my $hard_due_date = $self->circ_matrix_matchpoint->hard_due_date;
1093
1094         my $policy = $self->get_circ_policy(
1095             $duration_rule, $recurring_fine_rule, $max_fine_rule, $hard_due_date);
1096
1097         $$results{$_} = $$policy{$_} for keys %$policy;
1098     }
1099
1100     return $results;
1101 }
1102
1103 # ---------------------------------------------------------------------
1104 # Loads the circ policy info for duration, recurring fine, and max
1105 # fine based on the current copy
1106 # ---------------------------------------------------------------------
1107 sub get_circ_policy {
1108     my($self, $duration_rule, $recurring_fine_rule, $max_fine_rule, $hard_due_date) = @_;
1109
1110     my $policy = {
1111         duration_rule => $duration_rule->name,
1112         recurring_fine_rule => $recurring_fine_rule->name,
1113         max_fine_rule => $max_fine_rule->name,
1114         max_fine => $self->get_max_fine_amount($max_fine_rule),
1115         fine_interval => $recurring_fine_rule->recurrence_interval,
1116         renewal_remaining => $duration_rule->max_renewals,
1117         grace_period => $recurring_fine_rule->grace_period
1118     };
1119
1120     if($hard_due_date) {
1121         $policy->{duration_date_ceiling} = $hard_due_date->ceiling_date;
1122         $policy->{duration_date_ceiling_force} = $hard_due_date->forceto;
1123     }
1124     else {
1125         $policy->{duration_date_ceiling} = undef;
1126         $policy->{duration_date_ceiling_force} = undef;
1127     }
1128
1129     $policy->{duration} = $duration_rule->shrt
1130         if $self->copy->loan_duration == OILS_CIRC_DURATION_SHORT;
1131     $policy->{duration} = $duration_rule->normal
1132         if $self->copy->loan_duration == OILS_CIRC_DURATION_NORMAL;
1133     $policy->{duration} = $duration_rule->extended
1134         if $self->copy->loan_duration == OILS_CIRC_DURATION_EXTENDED;
1135
1136     $policy->{recurring_fine} = $recurring_fine_rule->low
1137         if $self->copy->fine_level == OILS_REC_FINE_LEVEL_LOW;
1138     $policy->{recurring_fine} = $recurring_fine_rule->normal
1139         if $self->copy->fine_level == OILS_REC_FINE_LEVEL_NORMAL;
1140     $policy->{recurring_fine} = $recurring_fine_rule->high
1141         if $self->copy->fine_level == OILS_REC_FINE_LEVEL_HIGH;
1142
1143     return $policy;
1144 }
1145
1146 sub get_max_fine_amount {
1147     my $self = shift;
1148     my $max_fine_rule = shift;
1149     my $max_amount = $max_fine_rule->amount;
1150
1151     # if is_percent is true then the max->amount is
1152     # use as a percentage of the copy price
1153     if ($U->is_true($max_fine_rule->is_percent)) {
1154         my $price = $U->get_copy_price($self->editor, $self->copy, $self->volume);
1155         $max_amount = $price * $max_fine_rule->amount / 100;
1156     } elsif (
1157         $U->ou_ancestor_setting_value(
1158             $self->circ_lib,
1159             'circ.max_fine.cap_at_price',
1160             $self->editor
1161         )
1162     ) {
1163         my $price = $U->get_copy_price($self->editor, $self->copy, $self->volume);
1164         $max_amount = ( $price && $max_amount > $price ) ? $price : $max_amount;
1165     }
1166
1167     return $max_amount;
1168 }
1169
1170
1171
1172 sub run_copy_permit_scripts {
1173     my $self = shift;
1174     my $copy = $self->copy || return;
1175
1176     my @allevents;
1177
1178     my $results = $self->run_indb_circ_test;
1179     push @allevents, $self->matrix_test_result_events
1180         unless $self->circ_test_success;
1181
1182     # See if this copy has an alert message
1183     my $ae = $self->check_copy_alert();
1184     push( @allevents, $ae ) if $ae;
1185
1186     # uniquify the events
1187     my %hash = map { ($_->{ilsevent} => $_) } @allevents;
1188     @allevents = values %hash;
1189
1190     $logger->info("circulator: permit_copy script returned events: @allevents") if @allevents;
1191
1192     $self->push_events(@allevents);
1193 }
1194
1195
1196 sub check_copy_alert {
1197     my $self = shift;
1198     return undef if $self->is_renewal;
1199     return OpenILS::Event->new(
1200         'COPY_ALERT_MESSAGE', payload => $self->copy->alert_message)
1201         if $self->copy and $self->copy->alert_message;
1202     return undef;
1203 }
1204
1205
1206
1207 # --------------------------------------------------------------------------
1208 # If the call is overriding and has permissions to override every collected
1209 # event, the are cleared.  Any event that the caller does not have
1210 # permission to override, will be left in the event list and bail_out will
1211 # be set
1212 # XXX We need code in here to cancel any holds/transits on copies
1213 # that are being force-checked out
1214 # --------------------------------------------------------------------------
1215 sub override_events {
1216     my $self = shift;
1217     my @events = @{$self->events};
1218     return unless @events;
1219     my $oargs = $self->override_args;
1220
1221     if(!$self->override) {
1222         return $self->bail_out(1)
1223             if( @events > 1 or $events[0]->{textcode} ne 'SUCCESS' );
1224     }
1225
1226     $self->events([]);
1227
1228     for my $e (@events) {
1229         my $tc = $e->{textcode};
1230         next if $tc eq 'SUCCESS';
1231         if($oargs->{all} || grep { $_ eq $tc } @{$oargs->{events}}) {
1232             my $ov = "$tc.override";
1233             $logger->info("circulator: attempting to override event: $ov");
1234
1235             return $self->bail_on_events($self->editor->event)
1236                 unless( $self->editor->allowed($ov) );
1237         } else {
1238             return $self->bail_out(1);
1239         }
1240    }
1241 }
1242
1243
1244 # --------------------------------------------------------------------------
1245 # If there is an open claimsreturn circ on the requested copy, close the
1246 # circ if overriding, otherwise bail out
1247 # --------------------------------------------------------------------------
1248 sub handle_claims_returned {
1249     my $self = shift;
1250     my $copy = $self->copy;
1251
1252     my $CR = $self->editor->search_action_circulation(
1253         {
1254             target_copy     => $copy->id,
1255             stop_fines      => OILS_STOP_FINES_CLAIMSRETURNED,
1256             checkin_time    => undef,
1257         }
1258     );
1259
1260     return unless ($CR = $CR->[0]);
1261
1262     my $evt;
1263
1264     # - If the caller has set the override flag, we will check the item in
1265     if($self->override && ($self->override_args->{all} || grep { $_ eq 'CIRC_CLAIMS_RETURNED' } @{$self->override_args->{events}}) ) {
1266
1267         $CR->checkin_time('now');
1268         $CR->checkin_scan_time('now');
1269         $CR->checkin_lib($self->circ_lib);
1270         $CR->checkin_workstation($self->editor->requestor->wsid);
1271         $CR->checkin_staff($self->editor->requestor->id);
1272
1273         $evt = $self->editor->event
1274             unless $self->editor->update_action_circulation($CR);
1275
1276     } else {
1277         $evt = OpenILS::Event->new('CIRC_CLAIMS_RETURNED');
1278     }
1279
1280     $self->bail_on_events($evt) if $evt;
1281     return;
1282 }
1283
1284
1285 # --------------------------------------------------------------------------
1286 # This performs the checkout
1287 # --------------------------------------------------------------------------
1288 sub do_checkout {
1289     my $self = shift;
1290
1291     $self->log_me("do_checkout()");
1292
1293     # make sure perms are good if this isn't a renewal
1294     unless( $self->is_renewal ) {
1295         return $self->bail_on_events($self->editor->event)
1296             unless( $self->editor->allowed('COPY_CHECKOUT') );
1297     }
1298
1299     # verify the permit key
1300     unless( $self->check_permit_key ) {
1301         if( $self->permit_override ) {
1302             return $self->bail_on_events($self->editor->event)
1303                 unless $self->editor->allowed('CIRC_PERMIT_OVERRIDE');
1304         } else {
1305             return $self->bail_on_events(OpenILS::Event->new('CIRC_PERMIT_BAD_KEY'))
1306         }
1307     }
1308
1309     # if this is a non-cataloged circ, build the circ and finish
1310     if( $self->is_noncat ) {
1311         $self->checkout_noncat;
1312         $self->push_events(
1313             OpenILS::Event->new('SUCCESS',
1314             payload => { noncat_circ => $self->circ }));
1315         return;
1316     }
1317
1318     if( $self->is_precat ) {
1319         $self->make_precat_copy;
1320         return if $self->bail_out;
1321
1322     } elsif( $self->copy->call_number == OILS_PRECAT_CALL_NUMBER ) {
1323         return $self->bail_on_events(OpenILS::Event->new('ITEM_NOT_CATALOGED'));
1324     }
1325
1326     $self->do_copy_checks;
1327     return if $self->bail_out;
1328
1329     $self->run_checkout_scripts();
1330     return if $self->bail_out;
1331
1332     $self->build_checkout_circ_object();
1333     return if $self->bail_out;
1334
1335     my $modify_to_start = $self->booking_adjusted_due_date();
1336     return if $self->bail_out;
1337
1338     $self->apply_modified_due_date($modify_to_start);
1339     return if $self->bail_out;
1340
1341     return $self->bail_on_events($self->editor->event)
1342         unless $self->editor->create_action_circulation($self->circ);
1343
1344     # refresh the circ to force local time zone for now
1345     $self->circ($self->editor->retrieve_action_circulation($self->circ->id));
1346
1347     if($self->limit_groups) {
1348         $self->editor->json_query({ from => ['action.link_circ_limit_groups', $self->circ->id, $self->limit_groups] });
1349     }
1350
1351     $self->copy->status(OILS_COPY_STATUS_CHECKED_OUT);
1352     $self->update_copy;
1353     return if $self->bail_out;
1354
1355     $self->apply_deposit_fee();
1356     return if $self->bail_out;
1357
1358     $self->handle_checkout_holds();
1359     return if $self->bail_out;
1360
1361     # ------------------------------------------------------------------------------
1362     # Update the patron penalty info in the DB.  Run it for permit-overrides
1363     # since the penalties are not updated during the permit phase
1364     # ------------------------------------------------------------------------------
1365     OpenILS::Utils::Penalty->calculate_penalties($self->editor, $self->patron->id, $self->circ_lib);
1366
1367     my $record = $U->record_to_mvr($self->title) unless $self->is_precat;
1368
1369     my $pcirc;
1370     if($self->is_renewal) {
1371         # flesh the billing summary for the checked-in circ
1372         $pcirc = $self->editor->retrieve_action_circulation([
1373             $self->parent_circ,
1374             {flesh => 2, flesh_fields => {circ => ['billable_transaction'], mbt => ['summary']}}
1375         ]);
1376     }
1377
1378     $self->push_events(
1379         OpenILS::Event->new('SUCCESS',
1380             payload  => {
1381                 copy             => $U->unflesh_copy($self->copy),
1382                 volume           => $self->volume,
1383                 circ             => $self->circ,
1384                 record           => $record,
1385                 holds_fulfilled  => $self->fulfilled_holds,
1386                 deposit_billing  => $self->deposit_billing,
1387                 rental_billing   => $self->rental_billing,
1388                 parent_circ      => $pcirc,
1389                 patron           => ($self->return_patron) ? $self->patron : undef,
1390                 patron_money     => $self->editor->retrieve_money_user_summary($self->patron->id)
1391             }
1392         )
1393     );
1394 }
1395
1396 sub apply_deposit_fee {
1397     my $self = shift;
1398     my $copy = $self->copy;
1399     return unless
1400         ($self->is_deposit and not $self->is_deposit_exempt) or
1401         ($self->is_rental and not $self->is_rental_exempt);
1402
1403     return if $self->is_deposit and $self->skip_deposit_fee;
1404     return if $self->is_rental and $self->skip_rental_fee;
1405
1406     my $bill = Fieldmapper::money::billing->new;
1407     my $amount = $copy->deposit_amount;
1408     my $billing_type;
1409     my $btype;
1410
1411     if($self->is_deposit) {
1412         $billing_type = OILS_BILLING_TYPE_DEPOSIT;
1413         $btype = 5;
1414         $self->deposit_billing($bill);
1415     } else {
1416         $billing_type = OILS_BILLING_TYPE_RENTAL;
1417         $btype = 6;
1418         $self->rental_billing($bill);
1419     }
1420
1421     $bill->xact($self->circ->id);
1422     $bill->amount($amount);
1423     $bill->note(OILS_BILLING_NOTE_SYSTEM);
1424     $bill->billing_type($billing_type);
1425     $bill->btype($btype);
1426     $self->editor->create_money_billing($bill) or $self->bail_on_events($self->editor->event);
1427
1428     $logger->info("circulator: charged $amount on checkout with billing type $billing_type");
1429 }
1430
1431 sub update_copy {
1432     my $self = shift;
1433     my $copy = $self->copy;
1434
1435     my $stat = $copy->status if ref $copy->status;
1436     my $loc = $copy->location if ref $copy->location;
1437     my $circ_lib = $copy->circ_lib if ref $copy->circ_lib;
1438
1439     $copy->status($stat->id) if $stat;
1440     $copy->location($loc->id) if $loc;
1441     $copy->circ_lib($circ_lib->id) if $circ_lib;
1442     $copy->editor($self->editor->requestor->id);
1443     $copy->edit_date('now');
1444     $copy->age_protect($copy->age_protect->id) if ref $copy->age_protect;
1445
1446     return $self->bail_on_events($self->editor->event)
1447         unless $self->editor->update_asset_copy($self->copy);
1448
1449     $copy->status($U->copy_status($copy->status));
1450     $copy->location($loc) if $loc;
1451     $copy->circ_lib($circ_lib) if $circ_lib;
1452 }
1453
1454 sub update_reservation {
1455     my $self = shift;
1456     my $reservation = $self->reservation;
1457
1458     my $usr = $reservation->usr;
1459     my $target_rt = $reservation->target_resource_type;
1460     my $target_r = $reservation->target_resource;
1461     my $current_r = $reservation->current_resource;
1462
1463     $reservation->usr($usr->id) if ref $usr;
1464     $reservation->target_resource_type($target_rt->id) if ref $target_rt;
1465     $reservation->target_resource($target_r->id) if ref $target_r;
1466     $reservation->current_resource($current_r->id) if ref $current_r;
1467
1468     return $self->bail_on_events($self->editor->event)
1469         unless $self->editor->update_booking_reservation($self->reservation);
1470
1471     my $evt;
1472     ($reservation, $evt) = $U->fetch_booking_reservation($reservation->id);
1473     $self->reservation($reservation);
1474 }
1475
1476
1477 sub bail_on_events {
1478     my( $self, @evts ) = @_;
1479     $self->push_events(@evts);
1480     $self->bail_out(1);
1481 }
1482
1483 # ------------------------------------------------------------------------------
1484 # A hold FULFILL block is just like a CIRC block, except that FULFILL only
1485 # affects copies that will fulfill holds and CIRC affects all other copies.
1486 # If blocks exists, bail, push Events onto the event pile, and return true.
1487 # ------------------------------------------------------------------------------
1488 sub check_hold_fulfill_blocks {
1489     my $self = shift;
1490
1491     # With the addition of ignore_proximity in csp, we need to fetch
1492     # the proximity of both the circ_lib and the copy's circ_lib to
1493     # the patron's home_ou.
1494     my ($ou_prox, $copy_prox);
1495     my $home_ou = (ref($self->patron->home_ou)) ? $self->patron->home_ou->id : $self->patron->home_ou;
1496     $ou_prox = $U->get_org_unit_proximity($self->editor, $home_ou, $self->circ_lib);
1497     $ou_prox = -1 unless (defined($ou_prox));
1498     my $copy_ou = (ref($self->copy->circ_lib)) ? $self->copy->circ_lib->id : $self->copy->circ_lib;
1499     if ($copy_ou == $self->circ_lib) {
1500         # Save us the time of an extra query.
1501         $copy_prox = $ou_prox;
1502     } else {
1503         $copy_prox = $U->get_org_unit_proximity($self->editor, $home_ou, $copy_ou);
1504         $copy_prox = -1 unless (defined($copy_prox));
1505     }
1506
1507     # See if the user has any penalties applied that prevent hold fulfillment
1508     my $pens = $self->editor->json_query({
1509         select => {csp => ['name', 'label']},
1510         from => {ausp => {csp => {}}},
1511         where => {
1512             '+ausp' => {
1513                 usr => $self->patron->id,
1514                 org_unit => $U->get_org_full_path($self->circ_lib),
1515                 '-or' => [
1516                     {stop_date => undef},
1517                     {stop_date => {'>' => 'now'}}
1518                 ]
1519             },
1520             '+csp' => {
1521                 block_list => {'like' => '%FULFILL%'},
1522                 '-or' => [
1523                     {ignore_proximity => undef},
1524                     {ignore_proximity => {'<' => $ou_prox}},
1525                     {ignore_proximity => {'<' => $copy_prox}}
1526                 ]
1527             }
1528         }
1529     });
1530
1531     return 0 unless @$pens;
1532
1533     for my $pen (@$pens) {
1534         $logger->info("circulator: patron has hold FULFILL block " . $pen->{name});
1535         my $event = OpenILS::Event->new($pen->{name});
1536         $event->{desc} = $pen->{label};
1537         $self->push_events($event);
1538     }
1539
1540     $self->override_events;
1541     return $self->bail_out;
1542 }
1543
1544
1545 # ------------------------------------------------------------------------------
1546 # When an item is checked out, see if we can fulfill a hold for this patron
1547 # ------------------------------------------------------------------------------
1548 sub handle_checkout_holds {
1549    my $self    = shift;
1550    my $copy    = $self->copy;
1551    my $patron  = $self->patron;
1552
1553    my $e = $self->editor;
1554    $self->fulfilled_holds([]);
1555
1556    # non-cats can't fulfill a hold
1557    return if $self->is_noncat;
1558
1559     my $hold = $e->search_action_hold_request({
1560         current_copy        => $copy->id ,
1561         cancel_time         => undef,
1562         fulfillment_time    => undef,
1563         '-or' => [
1564             {expire_time => undef},
1565             {expire_time => {'>' => 'now'}}
1566         ]
1567     })->[0];
1568
1569     if($hold and $hold->usr != $patron->id) {
1570         # reset the hold since the copy is now checked out
1571
1572         $logger->info("circulator: un-targeting hold ".$hold->id.
1573             " because copy ".$copy->id." is getting checked out");
1574
1575         $hold->clear_prev_check_time;
1576         $hold->clear_current_copy;
1577         $hold->clear_capture_time;
1578         $hold->clear_shelf_time;
1579         $hold->clear_shelf_expire_time;
1580         $hold->clear_current_shelf_lib;
1581
1582         return $self->bail_on_event($e->event)
1583             unless $e->update_action_hold_request($hold);
1584
1585         $hold = undef;
1586     }
1587
1588     unless($hold) {
1589         $hold = $self->find_related_user_hold($copy, $patron) or return;
1590         $logger->info("circulator: found related hold to fulfill in checkout");
1591     }
1592
1593     return if $self->check_hold_fulfill_blocks;
1594
1595     $logger->debug("circulator: checkout fulfilling hold " . $hold->id);
1596
1597     # if the hold was never officially captured, capture it.
1598     $hold->current_copy($copy->id);
1599     $hold->capture_time('now') unless $hold->capture_time;
1600     $hold->fulfillment_time('now');
1601     $hold->fulfillment_staff($e->requestor->id);
1602     $hold->fulfillment_lib($self->circ_lib);
1603
1604     return $self->bail_on_events($e->event)
1605         unless $e->update_action_hold_request($hold);
1606
1607     return $self->fulfilled_holds([$hold->id]);
1608 }
1609
1610
1611 # ------------------------------------------------------------------------------
1612 # If the circ.checkout_fill_related_hold setting is turned on and no hold for
1613 # the patron directly targets the checked out item, see if there is another hold
1614 # for the patron that could be fulfilled by the checked out item.  Fulfill the
1615 # oldest hold and only fulfill 1 of them.
1616 #
1617 # For "another hold":
1618 #
1619 # First, check for one that the copy matches via hold_copy_map, ensuring that
1620 # *any* hold type that this copy could fill may end up filled.
1621 #
1622 # Then, if circ.checkout_fill_related_hold_exact_match_only is not enabled, look
1623 # for a Title (T) or Volume (V) hold that matches the item. This allows items
1624 # that are non-requestable to count as capturing those hold types.
1625 # ------------------------------------------------------------------------------
1626 sub find_related_user_hold {
1627     my($self, $copy, $patron) = @_;
1628     my $e = $self->editor;
1629
1630     # holds on precat copies are always copy-level, so this call will
1631     # always return undef.  Exit early.
1632     return undef if $self->is_precat;
1633
1634     return undef unless $U->ou_ancestor_setting_value(
1635         $self->circ_lib, 'circ.checkout_fills_related_hold', $e);
1636
1637     # find the oldest unfulfilled hold that has not yet hit the holds shelf.
1638     my $args = {
1639         select => {ahr => ['id']},
1640         from => {
1641             ahr => {
1642                 ahcm => {
1643                     field => 'hold',
1644                     fkey => 'id'
1645                 },
1646                 acp => {
1647                     field => 'id',
1648                     fkey => 'current_copy',
1649                     type => 'left' # there may be no current_copy
1650                 }
1651             }
1652         },
1653         where => {
1654             '+ahr' => {
1655                 usr => $patron->id,
1656                 fulfillment_time => undef,
1657                 cancel_time => undef,
1658                '-or' => [
1659                     {expire_time => undef},
1660                     {expire_time => {'>' => 'now'}}
1661                 ]
1662             },
1663             '+ahcm' => {
1664                 target_copy => $self->copy->id
1665             },
1666             '+acp' => {
1667                 '-or' => [
1668                     {id => undef}, # left-join copy may be nonexistent
1669                     {status => {'!=' => OILS_COPY_STATUS_ON_HOLDS_SHELF}},
1670                 ]
1671             }
1672         },
1673         order_by => {ahr => {request_time => {direction => 'asc'}}},
1674         limit => 1
1675     };
1676
1677     my $hold_info = $e->json_query($args)->[0];
1678     return $e->retrieve_action_hold_request($hold_info->{id}) if $hold_info;
1679     return undef if $U->ou_ancestor_setting_value(
1680         $self->circ_lib, 'circ.checkout_fills_related_hold_exact_match_only', $e);
1681
1682     # find the oldest unfulfilled hold that has not yet hit the holds shelf.
1683     $args = {
1684         select => {ahr => ['id']},
1685         from => {
1686             ahr => {
1687                 acp => {
1688                     field => 'id',
1689                     fkey => 'current_copy',
1690                     type => 'left' # there may be no current_copy
1691                 }
1692             }
1693         },
1694         where => {
1695             '+ahr' => {
1696                 usr => $patron->id,
1697                 fulfillment_time => undef,
1698                 cancel_time => undef,
1699                '-or' => [
1700                     {expire_time => undef},
1701                     {expire_time => {'>' => 'now'}}
1702                 ]
1703             },
1704             '-or' => [
1705                 {
1706                     '+ahr' => {
1707                         hold_type => 'V',
1708                         target => $self->volume->id
1709                     }
1710                 },
1711                 {
1712                     '+ahr' => {
1713                         hold_type => 'T',
1714                         target => $self->title->id
1715                     }
1716                 },
1717             ],
1718             '+acp' => {
1719                 '-or' => [
1720                     {id => undef}, # left-join copy may be nonexistent
1721                     {status => {'!=' => OILS_COPY_STATUS_ON_HOLDS_SHELF}},
1722                 ]
1723             }
1724         },
1725         order_by => {ahr => {request_time => {direction => 'asc'}}},
1726         limit => 1
1727     };
1728
1729     $hold_info = $e->json_query($args)->[0];
1730     return $e->retrieve_action_hold_request($hold_info->{id}) if $hold_info;
1731     return undef;
1732 }
1733
1734
1735 sub run_checkout_scripts {
1736     my $self = shift;
1737     my $nobail = shift;
1738
1739     my $evt;
1740
1741     my $duration;
1742     my $recurring;
1743     my $max_fine;
1744     my $hard_due_date;
1745     my $duration_name;
1746     my $recurring_name;
1747     my $max_fine_name;
1748     my $hard_due_date_name;
1749
1750     $self->run_indb_circ_test();
1751     $duration = $self->circ_matrix_matchpoint->duration_rule;
1752     $recurring = $self->circ_matrix_matchpoint->recurring_fine_rule;
1753     $max_fine = $self->circ_matrix_matchpoint->max_fine_rule;
1754     $hard_due_date = $self->circ_matrix_matchpoint->hard_due_date;
1755
1756     $duration_name = $duration->name if $duration;
1757     if( $duration_name ne OILS_UNLIMITED_CIRC_DURATION ) {
1758
1759         unless($duration) {
1760             ($duration, $evt) = $U->fetch_circ_duration_by_name($duration_name);
1761             return $self->bail_on_events($evt) if ($evt && !$nobail);
1762
1763             ($recurring, $evt) = $U->fetch_recurring_fine_by_name($recurring_name);
1764             return $self->bail_on_events($evt) if ($evt && !$nobail);
1765
1766             ($max_fine, $evt) = $U->fetch_max_fine_by_name($max_fine_name);
1767             return $self->bail_on_events($evt) if ($evt && !$nobail);
1768
1769             if($hard_due_date_name) {
1770                 ($hard_due_date, $evt) = $U->fetch_hard_due_date_by_name($hard_due_date_name);
1771                 return $self->bail_on_events($evt) if ($evt && !$nobail);
1772             }
1773         }
1774
1775     } else {
1776
1777         # The item circulates with an unlimited duration
1778         $duration   = undef;
1779         $recurring  = undef;
1780         $max_fine   = undef;
1781         $hard_due_date = undef;
1782     }
1783
1784    $self->duration_rule($duration);
1785    $self->recurring_fines_rule($recurring);
1786    $self->max_fine_rule($max_fine);
1787    $self->hard_due_date($hard_due_date);
1788 }
1789
1790
1791 sub build_checkout_circ_object {
1792     my $self = shift;
1793
1794    my $circ       = Fieldmapper::action::circulation->new;
1795    my $duration   = $self->duration_rule;
1796    my $max        = $self->max_fine_rule;
1797    my $recurring  = $self->recurring_fines_rule;
1798    my $hard_due_date    = $self->hard_due_date;
1799    my $copy       = $self->copy;
1800    my $patron     = $self->patron;
1801    my $duration_date_ceiling;
1802    my $duration_date_ceiling_force;
1803
1804     if( $duration ) {
1805
1806         my $policy = $self->get_circ_policy($duration, $recurring, $max, $hard_due_date);
1807         $duration_date_ceiling = $policy->{duration_date_ceiling};
1808         $duration_date_ceiling_force = $policy->{duration_date_ceiling_force};
1809
1810         my $dname = $duration->name;
1811         my $mname = $max->name;
1812         my $rname = $recurring->name;
1813         my $hdname = '';
1814         if($hard_due_date) {
1815             $hdname = $hard_due_date->name;
1816         }
1817
1818         $logger->debug("circulator: building circulation ".
1819             "with duration=$dname, maxfine=$mname, recurring=$rname, hard due date=$hdname");
1820
1821         $circ->duration($policy->{duration});
1822         $circ->recurring_fine($policy->{recurring_fine});
1823         $circ->duration_rule($duration->name);
1824         $circ->recurring_fine_rule($recurring->name);
1825         $circ->max_fine_rule($max->name);
1826         $circ->max_fine($policy->{max_fine});
1827         $circ->fine_interval($recurring->recurrence_interval);
1828         $circ->renewal_remaining($duration->max_renewals);
1829         $circ->grace_period($policy->{grace_period});
1830
1831     } else {
1832
1833         $logger->info("circulator: copy found with an unlimited circ duration");
1834         $circ->duration_rule(OILS_UNLIMITED_CIRC_DURATION);
1835         $circ->recurring_fine_rule(OILS_UNLIMITED_CIRC_DURATION);
1836         $circ->max_fine_rule(OILS_UNLIMITED_CIRC_DURATION);
1837         $circ->renewal_remaining(0);
1838         $circ->grace_period(0);
1839     }
1840
1841    $circ->target_copy( $copy->id );
1842    $circ->usr( $patron->id );
1843    $circ->circ_lib( $self->circ_lib );
1844    $circ->workstation($self->editor->requestor->wsid)
1845     if defined $self->editor->requestor->wsid;
1846
1847     # renewals maintain a link to the parent circulation
1848     $circ->parent_circ($self->parent_circ);
1849
1850    if( $self->is_renewal ) {
1851       $circ->opac_renewal('t') if $self->opac_renewal;
1852       $circ->phone_renewal('t') if $self->phone_renewal;
1853       $circ->desk_renewal('t') if $self->desk_renewal;
1854       $circ->renewal_remaining($self->renewal_remaining);
1855       $circ->circ_staff($self->editor->requestor->id);
1856    }
1857
1858
1859     # if the user provided an overiding checkout time,
1860     # (e.g. the checkout really happened several hours ago), then
1861     # we apply that here.  Does this need a perm??
1862     $circ->xact_start(cleanse_ISO8601($self->checkout_time))
1863         if $self->checkout_time;
1864
1865     # if a patron is renewing, 'requestor' will be the patron
1866     $circ->circ_staff($self->editor->requestor->id);
1867     $circ->due_date( $self->create_due_date($circ->duration, $duration_date_ceiling, $duration_date_ceiling_force, $circ->xact_start) ) if $circ->duration;
1868
1869     $self->circ($circ);
1870 }
1871
1872 sub do_reservation_pickup {
1873     my $self = shift;
1874
1875     $self->log_me("do_reservation_pickup()");
1876
1877     $self->reservation->pickup_time('now');
1878
1879     if (
1880         $self->reservation->current_resource &&
1881         $U->is_true($self->reservation->target_resource_type->catalog_item)
1882     ) {
1883         # We used to try to set $self->copy and $self->patron here,
1884         # but that should already be done.
1885
1886         $self->run_checkout_scripts(1);
1887
1888         my $duration   = $self->duration_rule;
1889         my $max        = $self->max_fine_rule;
1890         my $recurring  = $self->recurring_fines_rule;
1891
1892         if ($duration && $max && $recurring) {
1893             my $policy = $self->get_circ_policy($duration, $recurring, $max);
1894
1895             my $dname = $duration->name;
1896             my $mname = $max->name;
1897             my $rname = $recurring->name;
1898
1899             $logger->debug("circulator: updating reservation ".
1900                 "with duration=$dname, maxfine=$mname, recurring=$rname");
1901
1902             $self->reservation->fine_amount($policy->{recurring_fine});
1903             $self->reservation->max_fine($policy->{max_fine});
1904             $self->reservation->fine_interval($recurring->recurrence_interval);
1905         }
1906
1907         $self->copy->status(OILS_COPY_STATUS_CHECKED_OUT);
1908         $self->update_copy();
1909
1910     } else {
1911         $self->reservation->fine_amount(
1912             $self->reservation->target_resource_type->fine_amount
1913         );
1914         $self->reservation->max_fine(
1915             $self->reservation->target_resource_type->max_fine
1916         );
1917         $self->reservation->fine_interval(
1918             $self->reservation->target_resource_type->fine_interval
1919         );
1920     }
1921
1922     $self->update_reservation();
1923 }
1924
1925 sub do_reservation_return {
1926     my $self = shift;
1927     my $request = shift;
1928
1929     $self->log_me("do_reservation_return()");
1930
1931     if (not ref $self->reservation) {
1932         my ($reservation, $evt) =
1933             $U->fetch_booking_reservation($self->reservation);
1934         return $self->bail_on_events($evt) if $evt;
1935         $self->reservation($reservation);
1936     }
1937
1938     $self->handle_fines(1);
1939     $self->reservation->return_time('now');
1940     $self->update_reservation();
1941     $self->reshelve_copy if $self->copy;
1942
1943     if ( $self->reservation->current_resource && $self->reservation->current_resource->catalog_item ) {
1944         $self->copy( $self->reservation->current_resource->catalog_item );
1945     }
1946 }
1947
1948 sub booking_adjusted_due_date {
1949     my $self = shift;
1950     my $circ = $self->circ;
1951     my $copy = $self->copy;
1952
1953     return undef unless $self->use_booking;
1954
1955     my $changed;
1956
1957     if( $self->due_date ) {
1958
1959         return $self->bail_on_events($self->editor->event)
1960             unless $self->editor->allowed('CIRC_OVERRIDE_DUE_DATE', $self->circ_lib);
1961
1962        $circ->due_date(cleanse_ISO8601($self->due_date));
1963
1964     } else {
1965
1966         return unless $copy and $circ->due_date;
1967     }
1968
1969     my $booking_items = $self->editor->search_booking_resource( { barcode => $copy->barcode } );
1970     if (@$booking_items) {
1971         my $booking_item = $booking_items->[0];
1972         my $resource_type = $self->editor->retrieve_booking_resource_type( $booking_item->type );
1973
1974         my $stop_circ_setting = $U->ou_ancestor_setting_value( $self->circ_lib, 'circ.booking_reservation.stop_circ', $self->editor );
1975         my $shorten_circ_setting = $resource_type->elbow_room ||
1976             $U->ou_ancestor_setting_value( $self->circ_lib, 'circ.booking_reservation.default_elbow_room', $self->editor ) ||
1977             '0 seconds';
1978
1979         my $booking_ses = OpenSRF::AppSession->create( 'open-ils.booking' );
1980         my $bookings = $booking_ses->request('open-ils.booking.reservations.filtered_id_list', $self->editor->authtoken, {
1981               resource     => $booking_item->id
1982             , search_start => 'now'
1983             , search_end   => $circ->due_date
1984             , fields       => { cancel_time => undef, return_time => undef }
1985         })->gather(1);
1986         $booking_ses->disconnect;
1987
1988         throw OpenSRF::EX::ERROR ("Improper input arguments") unless defined $bookings;
1989         return $self->bail_on_events($bookings) if ref($bookings) eq 'HASH';
1990
1991         my $dt_parser = DateTime::Format::ISO8601->new;
1992         my $due_date = $dt_parser->parse_datetime( cleanse_ISO8601($circ->due_date) );
1993
1994         for my $bid (@$bookings) {
1995
1996             my $booking = $self->editor->retrieve_booking_reservation( $bid );
1997
1998             my $booking_start = $dt_parser->parse_datetime( cleanse_ISO8601($booking->start_time) );
1999             my $booking_end = $dt_parser->parse_datetime( cleanse_ISO8601($booking->end_time) );
2000
2001             return $self->bail_on_events( OpenILS::Event->new('COPY_RESERVED') )
2002                 if ($booking_start < DateTime->now);
2003
2004
2005             if ($U->is_true($stop_circ_setting)) {
2006                 $self->bail_on_events( OpenILS::Event->new('COPY_RESERVED') );
2007             } else {
2008                 $due_date = $booking_start->subtract( seconds => interval_to_seconds($shorten_circ_setting) );
2009                 $self->bail_on_events( OpenILS::Event->new('COPY_RESERVED') ) if ($due_date < DateTime->now);
2010             }
2011
2012             # We set the circ duration here only to affect the logic that will
2013             # later (in a DB trigger) mangle the time part of the due date to
2014             # 11:59pm. Having any circ duration that is not a whole number of
2015             # days is enough to prevent the "correction."
2016             my $new_circ_duration = $due_date->epoch - time;
2017             $new_circ_duration++ if $new_circ_duration % 86400 == 0;
2018             $circ->duration("$new_circ_duration seconds");
2019
2020             $circ->due_date(cleanse_ISO8601($due_date->strftime('%FT%T%z')));
2021             $changed = 1;
2022         }
2023
2024         return $self->bail_on_events($self->editor->event)
2025             unless $self->editor->allowed('CIRC_OVERRIDE_DUE_DATE', $self->circ_lib);
2026     }
2027
2028     return $changed;
2029 }
2030
2031 sub apply_modified_due_date {
2032     my $self = shift;
2033     my $shift_earlier = shift;
2034     my $circ = $self->circ;
2035     my $copy = $self->copy;
2036
2037    if( $self->due_date ) {
2038
2039         return $self->bail_on_events($self->editor->event)
2040             unless $self->editor->allowed('CIRC_OVERRIDE_DUE_DATE', $self->circ_lib);
2041
2042       $circ->due_date(cleanse_ISO8601($self->due_date));
2043
2044    } else {
2045
2046       # if the due_date lands on a day when the location is closed
2047       return unless $copy and $circ->due_date;
2048
2049         #my $org = (ref $copy->circ_lib) ? $copy->circ_lib->id : $copy->circ_lib;
2050
2051         # due-date overlap should be determined by the location the item
2052         # is checked out from, not the owning or circ lib of the item
2053         my $org = $self->circ_lib;
2054
2055       $logger->info("circulator: circ searching for closed date overlap on lib $org".
2056             " with an item due date of ".$circ->due_date );
2057
2058       my $dateinfo = $U->storagereq(
2059          'open-ils.storage.actor.org_unit.closed_date.overlap',
2060             $org, $circ->due_date );
2061
2062       if($dateinfo) {
2063          $logger->info("circulator: $dateinfo : circ due data / close date overlap found : due_date=".
2064             $circ->due_date." start=". $dateinfo->{start}.", end=".$dateinfo->{end});
2065
2066             # XXX make the behavior more dynamic
2067             # for now, we just push the due date to after the close date
2068             if ($shift_earlier) {
2069                 $circ->due_date($dateinfo->{start});
2070             } else {
2071                 $circ->due_date($dateinfo->{end});
2072             }
2073       }
2074    }
2075 }
2076
2077
2078
2079 sub create_due_date {
2080     my( $self, $duration, $date_ceiling, $force_date, $start_time ) = @_;
2081
2082     # if there is a raw time component (e.g. from postgres),
2083     # turn it into an interval that interval_to_seconds can parse
2084     $duration =~ s/(\d{2}):(\d{2}):(\d{2})/$1 h $2 m $3 s/o;
2085
2086     # for now, use the server timezone.  TODO: use workstation org timezone
2087     my $due_date = DateTime->now(time_zone => 'local');
2088     $due_date = DateTime::Format::ISO8601->new->parse_datetime(cleanse_ISO8601($start_time)) if $start_time;
2089
2090     # add the circ duration
2091     $due_date->add(seconds => OpenSRF::Utils->interval_to_seconds($duration));
2092
2093     if($date_ceiling) {
2094         my $cdate = DateTime::Format::ISO8601->new->parse_datetime(cleanse_ISO8601($date_ceiling));
2095         if ($cdate > DateTime->now and ($cdate < $due_date or $U->is_true( $force_date ))) {
2096             $logger->info("circulator: overriding due date with date ceiling: $date_ceiling");
2097             $due_date = $cdate;
2098         }
2099     }
2100
2101     # return ISO8601 time with timezone
2102     return $due_date->strftime('%FT%T%z');
2103 }
2104
2105
2106
2107 sub make_precat_copy {
2108     my $self = shift;
2109     my $copy = $self->copy;
2110
2111    if($copy) {
2112         $logger->debug("circulator: Pre-cat copy already exists in checkout: ID=" . $copy->id);
2113
2114         $copy->editor($self->editor->requestor->id);
2115         $copy->edit_date('now');
2116         $copy->dummy_title($self->dummy_title || $copy->dummy_title || '');
2117         $copy->dummy_isbn($self->dummy_isbn || $copy->dummy_isbn || '');
2118         $copy->dummy_author($self->dummy_author || $copy->dummy_author || '');
2119         $copy->circ_modifier($self->circ_modifier || $copy->circ_modifier);
2120         $self->update_copy();
2121         return;
2122    }
2123
2124     $logger->info("circulator: Creating a new precataloged ".
2125         "copy in checkout with barcode " . $self->copy_barcode);
2126
2127     $copy = Fieldmapper::asset::copy->new;
2128     $copy->circ_lib($self->circ_lib);
2129     $copy->creator($self->editor->requestor->id);
2130     $copy->editor($self->editor->requestor->id);
2131     $copy->barcode($self->copy_barcode);
2132     $copy->call_number(OILS_PRECAT_CALL_NUMBER);
2133     $copy->loan_duration(OILS_PRECAT_COPY_LOAN_DURATION);
2134     $copy->fine_level(OILS_PRECAT_COPY_FINE_LEVEL);
2135
2136     $copy->dummy_title($self->dummy_title || "");
2137     $copy->dummy_author($self->dummy_author || "");
2138     $copy->dummy_isbn($self->dummy_isbn || "");
2139     $copy->circ_modifier($self->circ_modifier);
2140
2141
2142     # See if we need to override the circ_lib for the copy with a configured circ_lib
2143     # Setting is shortname of the org unit
2144     my $precat_circ_lib = $U->ou_ancestor_setting_value(
2145         $self->circ_lib, 'circ.pre_cat_copy_circ_lib', $self->editor);
2146
2147     if($precat_circ_lib) {
2148         my $org = $self->editor->search_actor_org_unit({shortname => $precat_circ_lib})->[0];
2149
2150         if(!$org) {
2151             $self->bail_on_events($self->editor->event);
2152             return;
2153         }
2154
2155         $copy->circ_lib($org->id);
2156     }
2157
2158
2159     unless( $self->copy($self->editor->create_asset_copy($copy)) ) {
2160         $self->bail_out(1);
2161         $self->push_events($self->editor->event);
2162         return;
2163     }
2164 }
2165
2166
2167 sub checkout_noncat {
2168     my $self = shift;
2169
2170     my $circ;
2171     my $evt;
2172
2173    my $lib      = $self->noncat_circ_lib || $self->circ_lib;
2174    my $count    = $self->noncat_count || 1;
2175    my $cotime   = cleanse_ISO8601($self->checkout_time) || "";
2176
2177    $logger->info("circulator: circ creating $count noncat circs with checkout time $cotime");
2178
2179    for(1..$count) {
2180
2181       ( $circ, $evt ) = OpenILS::Application::Circ::NonCat::create_non_cat_circ(
2182          $self->editor->requestor->id,
2183             $self->patron->id,
2184             $lib,
2185             $self->noncat_type,
2186             $cotime,
2187             $self->editor );
2188
2189         if( $evt ) {
2190             $self->push_events($evt);
2191             $self->bail_out(1);
2192             return;
2193         }
2194         $self->circ($circ);
2195    }
2196 }
2197
2198 # If a copy goes into transit and is then checked in before the transit checkin
2199 # interval has expired, push an event onto the overridable events list.
2200 sub check_transit_checkin_interval {
2201     my $self = shift;
2202
2203     # only concerned with in-transit items
2204     return unless $U->copy_status($self->copy->status)->id == OILS_COPY_STATUS_IN_TRANSIT;
2205
2206     # no interval, no problem
2207     my $interval = $U->ou_ancestor_setting_value($self->circ_lib, 'circ.transit.min_checkin_interval');
2208     return unless $interval;
2209
2210     # capture the transit so we don't have to fetch it again later during checkin
2211     $self->transit(
2212         $self->editor->search_action_transit_copy(
2213             {target_copy => $self->copy->id, dest_recv_time => undef}
2214         )->[0]
2215     );
2216
2217     # transit from X to X for whatever reason has no min interval
2218     return if $self->transit->source == $self->transit->dest;
2219
2220     my $seconds = OpenSRF::Utils->interval_to_seconds($interval);
2221     my $t_start = DateTime::Format::ISO8601->new->parse_datetime(cleanse_ISO8601($self->transit->source_send_time));
2222     my $horizon = $t_start->add(seconds => $seconds);
2223
2224     # See if we are still within the transit checkin forbidden range
2225     $self->push_events(OpenILS::Event->new('TRANSIT_CHECKIN_INTERVAL_BLOCK'))
2226         if $horizon > DateTime->now;
2227 }
2228
2229 # Retarget local holds at checkin
2230 sub checkin_retarget {
2231     my $self = shift;
2232     return unless $self->retarget_mode and $self->retarget_mode =~ m/retarget/; # Retargeting?
2233     return unless $self->is_checkin; # Renewals need not be checked
2234     return if $self->capture eq 'nocapture'; # Not capturing holds anyway? Move on.
2235     return if $self->is_precat; # No holds for precats
2236     return unless $self->circ_lib == $self->copy->circ_lib; # Item isn't "home"? Don't check.
2237     return unless $U->is_true($self->copy->holdable); # Not holdable, shouldn't capture holds.
2238     my $status = $U->copy_status($self->copy->status);
2239     return unless $U->is_true($status->holdable); # Current status not holdable means no hold will ever target the item
2240     # Specifically target items that are likely new (by status ID)
2241     return unless $status->id == OILS_COPY_STATUS_IN_PROCESS || $self->retarget_mode =~ m/\.all/;
2242     my $location = $self->copy->location;
2243     if(!ref($location)) {
2244         $location = $self->editor->retrieve_asset_copy_location($self->copy->location);
2245         $self->copy->location($location);
2246     }
2247     return unless $U->is_true($location->holdable); # Don't bother on non-holdable locations
2248
2249     # Fetch holds for the bib
2250     my ($result) = $holdcode->method_lookup('open-ils.circ.holds.retrieve_all_from_title')->run(
2251                     $self->editor->authtoken,
2252                     $self->title->id,
2253                     {
2254                         capture_time => undef, # No touching captured holds
2255                         frozen => 'f', # Don't bother with frozen holds
2256                         pickup_lib => $self->circ_lib # Only holds actually here
2257                     });
2258
2259     # Error? Skip the step.
2260     return if exists $result->{"ilsevent"};
2261
2262     # Assemble holds
2263     my $holds = [];
2264     foreach my $holdlist (keys %{$result}) {
2265         push @$holds, @{$result->{$holdlist}};
2266     }
2267
2268     return if scalar(@$holds) == 0; # No holds, no retargeting
2269
2270     # Check for parts on this copy
2271     my $parts = $self->editor->search_asset_copy_part_map({ target_copy => $self->copy->id });
2272     my %parts_hash = ();
2273     %parts_hash = map {$_->part, 1} @$parts if @$parts;
2274
2275     # Loop over holds in request-ish order
2276     # Stage 1: Get them into request-ish order
2277     # Also grab type and target for skipping low hanging ones
2278     $result = $self->editor->json_query({
2279         "select" => { "ahr" => ["id", "hold_type", "target"] },
2280         "from" => { "ahr" => { "au" => { "fkey" => "usr",  "join" => "pgt"} } },
2281         "where" => { "id" => $holds },
2282         "order_by" => [
2283             { "class" => "pgt", "field" => "hold_priority"},
2284             { "class" => "ahr", "field" => "cut_in_line", "direction" => "desc", "transform" => "coalesce", "params" => ['f']},
2285             { "class" => "ahr", "field" => "selection_depth", "direction" => "desc"},
2286             { "class" => "ahr", "field" => "request_time"}
2287         ]
2288     });
2289
2290     # Stage 2: Loop!
2291     if (ref $result eq "ARRAY" and scalar @$result) {
2292         foreach (@{$result}) {
2293             # Copy level, but not this copy?
2294             next if ($_->{hold_type} eq 'C' or $_->{hold_type} eq 'R' or $_->{hold_type} eq 'F'
2295                 and $_->{target} != $self->copy->id);
2296             # Volume level, but not this volume?
2297             next if ($_->{hold_type} eq 'V' and $_->{target} != $self->volume->id);
2298             if(@$parts) { # We have parts?
2299                 # Skip title holds
2300                 next if ($_->{hold_type} eq 'T');
2301                 # Skip part holds for parts not on this copy
2302                 next if ($_->{hold_type} eq 'P' and not $parts_hash{$_->{target}});
2303             } else {
2304                 # No parts, no part holds
2305                 next if ($_->{hold_type} eq 'P');
2306             }
2307             # So much for easy stuff, attempt a retarget!
2308             my $tresult = $U->storagereq('open-ils.storage.action.hold_request.copy_targeter', undef, $_->{id}, $self->copy->id);
2309             if(ref $tresult eq "ARRAY" and scalar @$tresult) {
2310                 last if(exists $tresult->[0]->{found_copy} and $tresult->[0]->{found_copy});
2311             }
2312         }
2313     }
2314 }
2315
2316 sub do_checkin {
2317     my $self = shift;
2318     $self->log_me("do_checkin()");
2319
2320     return $self->bail_on_events(
2321         OpenILS::Event->new('ASSET_COPY_NOT_FOUND'))
2322         unless $self->copy;
2323
2324     $self->check_transit_checkin_interval;
2325     $self->checkin_retarget;
2326
2327     # the renew code and mk_env should have already found our circulation object
2328     unless( $self->circ ) {
2329
2330         my $circs = $self->editor->search_action_circulation(
2331             { target_copy => $self->copy->id, checkin_time => undef });
2332
2333         $self->circ($$circs[0]);
2334
2335         # for now, just warn if there are multiple open circs on a copy
2336         $logger->warn("circulator: we have ".scalar(@$circs).
2337             " open circs for copy " .$self->copy->id."!!") if @$circs > 1;
2338     }
2339
2340     my $stat = $U->copy_status($self->copy->status)->id;
2341
2342     # LOST (and to some extent, LONGOVERDUE) may optionally be handled
2343     # differently if they are already paid for.  We need to check for this
2344     # early since overdue generation is potentially affected.
2345     my $dont_change_lost_zero = 0;
2346     if ($stat == OILS_COPY_STATUS_LOST
2347         || $stat == OILS_COPY_STATUS_LOST_AND_PAID
2348         || $stat == OILS_COPY_STATUS_LONG_OVERDUE) {
2349
2350         # LOST fine settings are controlled by the copy's circ lib, not the the
2351         # circulation's
2352         my $copy_circ_lib = (ref $self->copy->circ_lib) ?
2353                 $self->copy->circ_lib->id : $self->copy->circ_lib;
2354         $dont_change_lost_zero = $U->ou_ancestor_setting_value(
2355             $copy_circ_lib, 'circ.checkin.lost_zero_balance.do_not_change',
2356             $self->editor) || 0;
2357
2358         if ($dont_change_lost_zero) {
2359             my ($obt) = $U->fetch_mbts($self->circ->id, $self->editor);
2360             $dont_change_lost_zero = 0 if( $obt and $obt->balance_owed != 0 );
2361         }
2362
2363         $self->dont_change_lost_zero($dont_change_lost_zero);
2364     }
2365
2366     if( $self->checkin_check_holds_shelf() ) {
2367         $self->bail_on_events(OpenILS::Event->new('NO_CHANGE'));
2368         $self->hold($U->fetch_open_hold_by_copy($self->copy->id));
2369         if($self->fake_hold_dest) {
2370             $self->hold->pickup_lib($self->circ_lib);
2371         }
2372         $self->checkin_flesh_events;
2373         return;
2374     }
2375
2376     unless( $self->is_renewal ) {
2377         return $self->bail_on_events($self->editor->event)
2378             unless $self->editor->allowed('COPY_CHECKIN');
2379     }
2380
2381     $self->push_events($self->check_copy_alert());
2382     $self->push_events($self->check_checkin_copy_status());
2383
2384     # if the circ is marked as 'claims returned', add the event to the list
2385     $self->push_events(OpenILS::Event->new('CIRC_CLAIMS_RETURNED'))
2386         if ($self->circ and $self->circ->stop_fines
2387                 and $self->circ->stop_fines eq OILS_STOP_FINES_CLAIMSRETURNED);
2388
2389     $self->check_circ_deposit();
2390
2391     # handle the overridable events
2392     $self->override_events unless $self->is_renewal;
2393     return if $self->bail_out;
2394
2395     if( $self->copy and !$self->transit ) {
2396         $self->transit(
2397             $self->editor->search_action_transit_copy(
2398                 { target_copy => $self->copy->id, dest_recv_time => undef }
2399             )->[0]
2400         );
2401     }
2402
2403     if( $self->circ ) {
2404         $self->checkin_handle_circ_start;
2405         return if $self->bail_out;
2406
2407         if (!$dont_change_lost_zero) {
2408             # if this circ is LOST and we are configured to generate overdue
2409             # fines for lost items on checkin (to fill the gap between mark
2410             # lost time and when the fines would have naturally stopped), then
2411             # stop_fines is no longer valid and should be cleared.
2412             #
2413             # stop_fines will be set again during the handle_fines() stage.
2414             # XXX should this setting come from the copy circ lib (like other
2415             # LOST settings), instead of the circulation circ lib?
2416             if ($stat == OILS_COPY_STATUS_LOST) {
2417                 $self->circ->clear_stop_fines if
2418                     $U->ou_ancestor_setting_value(
2419                         $self->circ_lib,
2420                         OILS_SETTING_GENERATE_OVERDUE_ON_LOST_RETURN,
2421                         $self->editor
2422                     );
2423             }
2424
2425             # Set stop_fines when claimed never checked out
2426             $self->circ->stop_fines( OILS_STOP_FINES_CLAIMS_NEVERCHECKEDOUT ) if( $self->claims_never_checked_out );
2427
2428             # handle fines for this circ, including overdue gen if needed
2429             $self->handle_fines;
2430         }
2431
2432         $self->checkin_handle_circ_finish;
2433         return if $self->bail_out;
2434         $self->checkin_changed(1);
2435
2436     } elsif( $self->transit ) {
2437         my $hold_transit = $self->process_received_transit;
2438         $self->checkin_changed(1);
2439
2440         if( $self->bail_out ) {
2441             $self->checkin_flesh_events;
2442             return;
2443         }
2444
2445         if( my $e = $self->check_checkin_copy_status() ) {
2446             # If the original copy status is special, alert the caller
2447             my $ev = $self->events;
2448             $self->events([$e]);
2449             $self->override_events;
2450             return if $self->bail_out;
2451             $self->events($ev);
2452         }
2453
2454         if( $hold_transit or
2455                 $U->copy_status($self->copy->status)->id
2456                     == OILS_COPY_STATUS_ON_HOLDS_SHELF ) {
2457
2458             my $hold;
2459             if( $hold_transit ) {
2460                $hold = $self->editor->retrieve_action_hold_request($hold_transit->hold);
2461             } else {
2462                    ($hold) = $U->fetch_open_hold_by_copy($self->copy->id);
2463             }
2464
2465             $self->hold($hold);
2466
2467             if( $hold and ( $hold->cancel_time or $hold->fulfillment_time ) ) { # this transited hold was cancelled or filled mid-transit
2468
2469                 $logger->info("circulator: we received a transit on a cancelled or filled hold " . $hold->id);
2470                 $self->reshelve_copy(1);
2471                 $self->cancelled_hold_transit(1);
2472                 $self->notify_hold(0); # don't notify for cancelled holds
2473                 $self->fake_hold_dest(0);
2474                 return if $self->bail_out;
2475
2476             } elsif ($hold and $hold->hold_type eq 'R') {
2477
2478                 $self->copy->status(OILS_COPY_STATUS_CATALOGING);
2479                 $self->notify_hold(0); # No need to notify
2480                 $self->fake_hold_dest(0);
2481                 $self->noop(1); # Don't try and capture for other holds/transits now
2482                 $self->update_copy();
2483                 $hold->fulfillment_time('now');
2484                 $self->bail_on_events($self->editor->event)
2485                     unless $self->editor->update_action_hold_request($hold);
2486
2487             } else {
2488
2489                 # hold transited to correct location
2490                 if($self->fake_hold_dest) {
2491                     $hold->pickup_lib($self->circ_lib);
2492                 }
2493                 $self->checkin_flesh_events;
2494                 return;
2495             }
2496         }
2497
2498     } elsif( $U->copy_status($self->copy->status)->id == OILS_COPY_STATUS_IN_TRANSIT ) {
2499
2500         $logger->warn("circulator: we have a copy ".$self->copy->barcode.
2501             " that is in-transit, but there is no transit.. repairing");
2502         $self->reshelve_copy(1);
2503         return if $self->bail_out;
2504     }
2505
2506     if( $self->is_renewal ) {
2507         $self->finish_fines_and_voiding;
2508         return if $self->bail_out;
2509         $self->push_events(OpenILS::Event->new('SUCCESS'));
2510         return;
2511     }
2512
2513    # ------------------------------------------------------------------------------
2514    # Circulations and transits are now closed where necessary.  Now go on to see if
2515    # this copy can fulfill a hold or needs to be routed to a different location
2516    # ------------------------------------------------------------------------------
2517
2518     my $needed_for_something = 0; # formerly "needed_for_hold"
2519
2520     if(!$self->noop) { # /not/ a no-op checkin, capture for hold or put item into transit
2521
2522         if (!$self->remote_hold) {
2523             if ($self->use_booking) {
2524                 my $potential_hold = $self->hold_capture_is_possible;
2525                 my $potential_reservation = $self->reservation_capture_is_possible;
2526
2527                 if ($potential_hold and $potential_reservation) {
2528                     $logger->info("circulator: item could fulfill either hold or reservation");
2529                     $self->push_events(new OpenILS::Event(
2530                         "HOLD_RESERVATION_CONFLICT",
2531                         "hold" => $potential_hold,
2532                         "reservation" => $potential_reservation
2533                     ));
2534                     return if $self->bail_out;
2535                 } elsif ($potential_hold) {
2536                     $needed_for_something =
2537                         $self->attempt_checkin_hold_capture;
2538                 } elsif ($potential_reservation) {
2539                     $needed_for_something =
2540                         $self->attempt_checkin_reservation_capture;
2541                 }
2542             } else {
2543                 $needed_for_something = $self->attempt_checkin_hold_capture;
2544             }
2545         }
2546         return if $self->bail_out;
2547
2548         unless($needed_for_something) {
2549             my $circ_lib = (ref $self->copy->circ_lib) ?
2550                     $self->copy->circ_lib->id : $self->copy->circ_lib;
2551
2552             if( $self->remote_hold ) {
2553                 $circ_lib = $self->remote_hold->pickup_lib;
2554                 $logger->warn("circulator: Copy ".$self->copy->barcode.
2555                     " is on a remote hold's shelf, sending to $circ_lib");
2556             }
2557
2558             $logger->debug("circulator: circlib=$circ_lib, workstation=".$self->circ_lib);
2559
2560             my $suppress_transit = 0;
2561
2562             if( $circ_lib != $self->circ_lib and not ($self->hold_as_transit and $self->remote_hold) ) {
2563                 my $suppress_transit_source = $U->ou_ancestor_setting($self->circ_lib, 'circ.transit.suppress_non_hold');
2564                 if($suppress_transit_source && $suppress_transit_source->{value}) {
2565                     my $suppress_transit_dest = $U->ou_ancestor_setting($circ_lib, 'circ.transit.suppress_non_hold');
2566                     if($suppress_transit_dest && $suppress_transit_source->{value} eq $suppress_transit_dest->{value}) {
2567                         $logger->info("circulator: copy is within transit suppress group: ".$self->copy->barcode." ".$suppress_transit_source->{value});
2568                         $suppress_transit = 1;
2569                     }
2570                 }
2571             }
2572
2573             if( $suppress_transit or ( $circ_lib == $self->circ_lib and not ($self->hold_as_transit and $self->remote_hold) ) ) {
2574                 # copy is where it needs to be, either for hold or reshelving
2575
2576                 $self->checkin_handle_precat();
2577                 return if $self->bail_out;
2578
2579             } else {
2580                 # copy needs to transit "home", or stick here if it's a floating copy
2581                 my $can_float = 0;
2582                 if ($self->copy->floating && ($self->manual_float || !$U->is_true($self->copy->floating->manual)) && !$self->remote_hold) { # copy is potentially floating?
2583                     my $res = $self->editor->json_query(
2584                         {   from => [
2585                                 'evergreen.can_float',
2586                                 $self->copy->floating->id,
2587                                 $self->copy->circ_lib,
2588                                 $self->circ_lib
2589                             ]
2590                         }
2591                     );
2592                     $can_float = $U->is_true($res->[0]->{'evergreen.can_float'}) if $res;
2593                 }
2594                 if ($can_float) { # Yep, floating, stick here
2595                     $self->checkin_changed(1);
2596                     $self->copy->circ_lib( $self->circ_lib );
2597                     $self->update_copy;
2598                 } else {
2599                     my $bc = $self->copy->barcode;
2600                     $logger->info("circulator: copy $bc at the wrong location, sending to $circ_lib");
2601                     $self->checkin_build_copy_transit($circ_lib);
2602                     return if $self->bail_out;
2603                     $self->push_events(OpenILS::Event->new('ROUTE_ITEM', org => $circ_lib));
2604                 }
2605             }
2606         }
2607     } else { # no-op checkin
2608         if ($self->copy->floating) { # XXX floating items still stick where they are even with no-op checkin?
2609             my $res = $self->editor->json_query(
2610                 {
2611                     from => [
2612                         'evergreen.can_float',
2613                         $self->copy->floating->id,
2614                         $self->copy->circ_lib,
2615                         $self->circ_lib
2616                     ]
2617                 }
2618             );
2619             if ($res && @$res && $U->is_true($res->[0]->{'evergreen.can_float'})) {
2620                 $self->checkin_changed(1);
2621                 $self->copy->circ_lib( $self->circ_lib );
2622                 $self->update_copy;
2623             }
2624         }
2625     }
2626
2627     if($self->claims_never_checked_out and
2628             $U->ou_ancestor_setting_value($self->circ->circ_lib, 'circ.claim_never_checked_out.mark_missing')) {
2629
2630         # the item was not supposed to be checked out to the user and should now be marked as missing
2631         $self->copy->status(OILS_COPY_STATUS_MISSING);
2632         $self->update_copy;
2633
2634     } else {
2635         $self->reshelve_copy unless $needed_for_something;
2636     }
2637
2638     return if $self->bail_out;
2639
2640     unless($self->checkin_changed) {
2641
2642         $self->push_events(OpenILS::Event->new('NO_CHANGE'));
2643         my $stat = $U->copy_status($self->copy->status)->id;
2644
2645         $self->hold($U->fetch_open_hold_by_copy($self->copy->id))
2646          if( $stat == OILS_COPY_STATUS_ON_HOLDS_SHELF );
2647         $self->bail_out(1); # no need to commit anything
2648
2649     } else {
2650
2651         $self->push_events(OpenILS::Event->new('SUCCESS'))
2652             unless @{$self->events};
2653     }
2654
2655     $self->finish_fines_and_voiding;
2656
2657     OpenILS::Utils::Penalty->calculate_penalties(
2658         $self->editor, $self->patron->id, $self->circ_lib) if $self->patron;
2659
2660     $self->checkin_flesh_events;
2661     return;
2662 }
2663
2664 sub finish_fines_and_voiding {
2665     my $self = shift;
2666     return unless $self->circ;
2667
2668     return unless $self->backdate or $self->void_overdues;
2669
2670     # void overdues after fine generation to prevent concurrent DB access to overdue billings
2671     my $note = 'System: Amnesty Checkin' if $self->void_overdues;
2672
2673     my $evt = $CC->void_or_zero_overdues(
2674         $self->editor, $self->circ, {backdate => $self->void_overdues ? undef : $self->backdate, note => $note});
2675
2676     return $self->bail_on_events($evt) if $evt;
2677
2678     # Make sure the circ is open or closed as necessary.
2679     $evt = $U->check_open_xact($self->editor, $self->circ->id);
2680     return $self->bail_on_events($evt) if $evt;
2681
2682     return undef;
2683 }
2684
2685
2686 # if a deposit was payed for this item, push the event
2687 sub check_circ_deposit {
2688     my $self = shift;
2689     return unless $self->circ;
2690     my $deposit = $self->editor->search_money_billing(
2691         {   btype => 5,
2692             xact => $self->circ->id,
2693             voided => 'f'
2694         }, {idlist => 1})->[0];
2695
2696     $self->push_events(OpenILS::Event->new(
2697         'ITEM_DEPOSIT_PAID', payload => $deposit)) if $deposit;
2698 }
2699
2700 sub reshelve_copy {
2701    my $self    = shift;
2702    my $force   = $self->force || shift;
2703    my $copy    = $self->copy;
2704
2705    my $stat = $U->copy_status($copy->status)->id;
2706
2707    if($force || (
2708       $stat != OILS_COPY_STATUS_ON_HOLDS_SHELF and
2709       $stat != OILS_COPY_STATUS_CATALOGING and
2710       $stat != OILS_COPY_STATUS_IN_TRANSIT and
2711       $stat != OILS_COPY_STATUS_RESHELVING  )) {
2712
2713         $copy->status( OILS_COPY_STATUS_RESHELVING );
2714             $self->update_copy;
2715             $self->checkin_changed(1);
2716     }
2717 }
2718
2719
2720 # Returns true if the item is at the current location
2721 # because it was transited there for a hold and the
2722 # hold has not been fulfilled
2723 sub checkin_check_holds_shelf {
2724     my $self = shift;
2725     return 0 unless $self->copy;
2726
2727     return 0 unless
2728         $U->copy_status($self->copy->status)->id ==
2729             OILS_COPY_STATUS_ON_HOLDS_SHELF;
2730
2731     # Attempt to clear shelf expired holds for this copy
2732     $holdcode->method_lookup('open-ils.circ.hold.clear_shelf.process')->run($self->editor->authtoken, $self->circ_lib, $self->copy->id)
2733         if($self->clear_expired);
2734
2735     # find the hold that put us on the holds shelf
2736     my $holds = $self->editor->search_action_hold_request(
2737         {
2738             current_copy => $self->copy->id,
2739             capture_time => { '!=' => undef },
2740             fulfillment_time => undef,
2741             cancel_time => undef,
2742         }
2743     );
2744
2745     unless(@$holds) {
2746         $logger->warn("circulator: copy is on-holds-shelf, but there is no hold - reshelving");
2747         $self->reshelve_copy(1);
2748         return 0;
2749     }
2750
2751     my $hold = $$holds[0];
2752
2753     $logger->info("circulator: we found a captured, un-fulfilled hold [".
2754         $hold->id. "] for copy ".$self->copy->barcode);
2755
2756     if( $hold->pickup_lib != $self->circ_lib and not $self->hold_as_transit ) {
2757         my $suppress_transit_circ = $U->ou_ancestor_setting($self->circ_lib, 'circ.transit.suppress_hold');
2758         if($suppress_transit_circ && $suppress_transit_circ->{value}) {
2759             my $suppress_transit_pickup = $U->ou_ancestor_setting($hold->pickup_lib, 'circ.transit.suppress_hold');
2760             if($suppress_transit_pickup && $suppress_transit_circ->{value} eq $suppress_transit_pickup->{value}) {
2761                 $logger->info("circulator: hold is within hold transit suppress group .. we're done: ".$self->copy->barcode." ".$suppress_transit_circ->{value});
2762                 $self->fake_hold_dest(1);
2763                 return 1;
2764             }
2765         }
2766     }
2767
2768     if( $hold->pickup_lib == $self->circ_lib and not $self->hold_as_transit ) {
2769         $logger->info("circulator: hold is for here .. we're done: ".$self->copy->barcode);
2770         return 1;
2771     }
2772
2773     $logger->info("circulator: hold is not for here..");
2774     $self->remote_hold($hold);
2775     return 0;
2776 }
2777
2778
2779 sub checkin_handle_precat {
2780     my $self    = shift;
2781    my $copy    = $self->copy;
2782
2783    if( $self->is_precat and ($copy->status != OILS_COPY_STATUS_CATALOGING) ) {
2784         $copy->status(OILS_COPY_STATUS_CATALOGING);
2785         $self->update_copy();
2786         $self->checkin_changed(1);
2787         $self->push_events(OpenILS::Event->new('ITEM_NOT_CATALOGED'));
2788    }
2789 }
2790
2791
2792 sub checkin_build_copy_transit {
2793     my $self            = shift;
2794     my $dest            = shift;
2795     my $copy       = $self->copy;
2796     my $transit    = Fieldmapper::action::transit_copy->new;
2797
2798     # if we are transiting an item to the shelf shelf, it's a hold transit
2799     if (my $hold = $self->remote_hold) {
2800         $transit = Fieldmapper::action::hold_transit_copy->new;
2801         $transit->hold($hold->id);
2802
2803         # the item is going into transit, remove any shelf-iness
2804         if ($hold->current_shelf_lib or $hold->shelf_time) {
2805             $hold->clear_current_shelf_lib;
2806             $hold->clear_shelf_time;
2807             return $self->bail_on_events($self->editor->event)
2808                 unless $self->editor->update_action_hold_request($hold);
2809         }
2810     }
2811
2812     #$dest  ||= (ref($copy->circ_lib)) ? $copy->circ_lib->id : $copy->circ_lib;
2813     $logger->info("circulator: transiting copy to $dest");
2814
2815     $transit->source($self->circ_lib);
2816     $transit->dest($dest);
2817     $transit->target_copy($copy->id);
2818     $transit->source_send_time('now');
2819     $transit->copy_status( $U->copy_status($copy->status)->id );
2820
2821     $logger->debug("circulator: setting copy status on transit: ".$transit->copy_status);
2822
2823     if ($self->remote_hold) {
2824         return $self->bail_on_events($self->editor->event)
2825             unless $self->editor->create_action_hold_transit_copy($transit);
2826     } else {
2827         return $self->bail_on_events($self->editor->event)
2828             unless $self->editor->create_action_transit_copy($transit);
2829     }
2830
2831     # ensure the transit is returned to the caller
2832     $self->transit($transit);
2833
2834     $copy->status(OILS_COPY_STATUS_IN_TRANSIT);
2835     $self->update_copy;
2836     $self->checkin_changed(1);
2837 }
2838
2839
2840 sub hold_capture_is_possible {
2841     my $self = shift;
2842     my $copy = $self->copy;
2843
2844     # we've been explicitly told not to capture any holds
2845     return 0 if $self->capture eq 'nocapture';
2846
2847     # See if this copy can fulfill any holds
2848     my $hold = $holdcode->find_nearest_permitted_hold(
2849         $self->editor, $copy, $self->editor->requestor, 1 # check_only
2850     );
2851     return undef if ref $hold eq "HASH" and
2852         $hold->{"textcode"} eq "ACTION_HOLD_REQUEST_NOT_FOUND";
2853     return $hold;
2854 }
2855
2856 sub reservation_capture_is_possible {
2857     my $self = shift;
2858     my $copy = $self->copy;
2859
2860     # we've been explicitly told not to capture any holds
2861     return 0 if $self->capture eq 'nocapture';
2862
2863     my $booking_ses = OpenSRF::AppSession->connect("open-ils.booking");
2864     my $resv = $booking_ses->request(
2865         "open-ils.booking.reservations.could_capture",
2866         $self->editor->authtoken, $copy->barcode
2867     )->gather(1);
2868     $booking_ses->disconnect;
2869     if (ref($resv) eq "HASH" and exists $resv->{"textcode"}) {
2870         $self->push_events($resv);
2871     } else {
2872         return $resv;
2873     }
2874 }
2875
2876 # returns true if the item was used (or may potentially be used
2877 # in subsequent calls) to capture a hold.
2878 sub attempt_checkin_hold_capture {
2879     my $self = shift;
2880     my $copy = $self->copy;
2881
2882     # we've been explicitly told not to capture any holds
2883     return 0 if $self->capture eq 'nocapture';
2884
2885     # See if this copy can fulfill any holds
2886     my ($hold, undef, $retarget) = $holdcode->find_nearest_permitted_hold(
2887         $self->editor, $copy, $self->editor->requestor );
2888
2889     if(!$hold) {
2890         $logger->debug("circulator: no potential permitted".
2891             "holds found for copy ".$copy->barcode);
2892         return 0;
2893     }
2894
2895     if($self->capture ne 'capture') {
2896         # see if this item is in a hold-capture-delay location
2897         my $location = $self->copy->location;
2898         if(!ref($location)) {
2899             $location = $self->editor->retrieve_asset_copy_location($self->copy->location);
2900             $self->copy->location($location);
2901         }
2902         if($U->is_true($location->hold_verify)) {
2903             $self->bail_on_events(
2904                 OpenILS::Event->new('HOLD_CAPTURE_DELAYED', copy_location => $location));
2905             return 1;
2906         }
2907     }
2908
2909     $self->retarget($retarget);
2910
2911     my $suppress_transit = 0;
2912     if( $hold->pickup_lib != $self->circ_lib and not $self->hold_as_transit ) {
2913         my $suppress_transit_circ = $U->ou_ancestor_setting($self->circ_lib, 'circ.transit.suppress_hold');
2914         if($suppress_transit_circ && $suppress_transit_circ->{value}) {
2915             my $suppress_transit_pickup = $U->ou_ancestor_setting($hold->pickup_lib, 'circ.transit.suppress_hold');
2916             if($suppress_transit_pickup && $suppress_transit_circ->{value} eq $suppress_transit_pickup->{value}) {
2917                 $suppress_transit = 1;
2918                 $hold->pickup_lib($self->circ_lib);
2919             }
2920         }
2921     }
2922
2923     $logger->info("circulator: found permitted hold ".$hold->id." for copy, capturing...");
2924
2925     $hold->current_copy($copy->id);
2926     $hold->capture_time('now');
2927     $self->put_hold_on_shelf($hold)
2928         if ($suppress_transit || ($hold->pickup_lib == $self->circ_lib and not $self->hold_as_transit) );
2929
2930     # prevent DB errors caused by fetching
2931     # holds from storage, and updating through cstore
2932     $hold->clear_fulfillment_time;
2933     $hold->clear_fulfillment_staff;
2934     $hold->clear_fulfillment_lib;
2935     $hold->clear_expire_time;
2936     $hold->clear_cancel_time;
2937     $hold->clear_prev_check_time unless $hold->prev_check_time;
2938
2939     $self->bail_on_events($self->editor->event)
2940         unless $self->editor->update_action_hold_request($hold);
2941     $self->hold($hold);
2942     $self->checkin_changed(1);
2943
2944     return 0 if $self->bail_out;
2945
2946     if( $suppress_transit or ( $hold->pickup_lib == $self->circ_lib && not $self->hold_as_transit ) ) {
2947
2948         if ($hold->hold_type eq 'R') {
2949             $copy->status(OILS_COPY_STATUS_CATALOGING);
2950             $hold->fulfillment_time('now');
2951             $self->noop(1); # Block other transit/hold checks
2952             $self->bail_on_events($self->editor->event)
2953                 unless $self->editor->update_action_hold_request($hold);
2954         } else {
2955             # This hold was captured in the correct location
2956             $copy->status(OILS_COPY_STATUS_ON_HOLDS_SHELF);
2957             $self->push_events(OpenILS::Event->new('SUCCESS'));
2958
2959             #$self->do_hold_notify($hold->id);
2960             $self->notify_hold($hold->id);
2961         }
2962
2963     } else {
2964
2965         # Hold needs to be picked up elsewhere.  Build a hold
2966         # transit and route the item.
2967         $self->checkin_build_hold_transit();
2968         $copy->status(OILS_COPY_STATUS_IN_TRANSIT);
2969         return 0 if $self->bail_out;
2970         $self->push_events(OpenILS::Event->new('ROUTE_ITEM', org => $hold->pickup_lib));
2971     }
2972
2973     # make sure we save the copy status
2974     $self->update_copy;
2975     return 0 if $copy->status == OILS_COPY_STATUS_CATALOGING;
2976     return 1;
2977 }
2978
2979 sub attempt_checkin_reservation_capture {
2980     my $self = shift;
2981     my $copy = $self->copy;
2982
2983     # we've been explicitly told not to capture any holds
2984     return 0 if $self->capture eq 'nocapture';
2985
2986     my $booking_ses = OpenSRF::AppSession->connect("open-ils.booking");
2987     my $evt = $booking_ses->request(
2988         "open-ils.booking.resources.capture_for_reservation",
2989         $self->editor->authtoken,
2990         $copy->barcode,
2991         1 # don't update copy - we probably have it locked
2992     )->gather(1);
2993     $booking_ses->disconnect;
2994
2995     if (ref($evt) ne "HASH" or not exists $evt->{"textcode"}) {
2996         $logger->warn(
2997             "open-ils.booking.resources.capture_for_reservation " .
2998             "didn't return an event!"
2999         );
3000     } else {
3001         if (
3002             $evt->{"textcode"} eq "RESERVATION_NOT_FOUND" and
3003             $evt->{"payload"}->{"fail_cause"} eq "not-transferable"
3004         ) {
3005             # not-transferable is an error event we'll pass on the user
3006             $logger->warn("reservation capture attempted against non-transferable item");
3007             $self->push_events($evt);
3008             return 0;
3009         } elsif ($evt->{"textcode"} eq "SUCCESS") {
3010             # Re-retrieve copy as reservation capture may have changed
3011             # its status and whatnot.
3012             $logger->info(
3013                 "circulator: booking capture win on copy " . $self->copy->id
3014             );
3015             if (my $new_copy_status = $evt->{"payload"}->{"new_copy_status"}) {
3016                 $logger->info(
3017                     "circulator: changing copy " . $self->copy->id .
3018                     "'s status from " . $self->copy->status . " to " .
3019                     $new_copy_status
3020                 );
3021                 $self->copy->status($new_copy_status);
3022                 $self->update_copy;
3023             }
3024             $self->reservation($evt->{"payload"}->{"reservation"});
3025
3026             if (exists $evt->{"payload"}->{"transit"}) {
3027                 $self->push_events(
3028                     new OpenILS::Event(
3029                         "ROUTE_ITEM",
3030                         "org" => $evt->{"payload"}->{"transit"}->dest
3031                     )
3032                 );
3033             }
3034             $self->checkin_changed(1);
3035             return 1;
3036         }
3037     }
3038     # other results are treated as "nothing to capture"
3039     return 0;
3040 }
3041
3042 sub do_hold_notify {
3043     my( $self, $holdid ) = @_;
3044
3045     my $e = new_editor(xact => 1);
3046     my $hold = $e->retrieve_action_hold_request($holdid) or return $e->die_event;
3047     $e->rollback;
3048     my $ses = OpenSRF::AppSession->create('open-ils.trigger');
3049     $ses->request('open-ils.trigger.event.autocreate', 'hold.available', $hold, $hold->pickup_lib);
3050
3051     $logger->info("circulator: running delayed hold notify process");
3052
3053 #   my $notifier = OpenILS::Application::Circ::HoldNotify->new(
3054 #       hold_id => $holdid, editor => new_editor(requestor=>$self->editor->requestor));
3055
3056     my $notifier = OpenILS::Application::Circ::HoldNotify->new(
3057         hold_id => $holdid, requestor => $self->editor->requestor);
3058
3059     $logger->debug("circulator: built hold notifier");
3060
3061     if(!$notifier->event) {
3062
3063         $logger->info("circulator: attempt at sending hold notification for hold $holdid");
3064
3065         my $stat = $notifier->send_email_notify;
3066         if( $stat == '1' ) {
3067             $logger->info("circulator: hold notify succeeded for hold $holdid");
3068             return;
3069         }
3070
3071         $logger->debug("circulator:  * hold notify cancelled or failed for hold $holdid");
3072
3073     } else {
3074         $logger->info("circulator: Not sending hold notification since the patron has no email address");
3075     }
3076 }
3077
3078 sub retarget_holds {
3079     my $self = shift;
3080     $logger->info("circulator: retargeting holds @{$self->retarget} after opportunistic capture");
3081     my $ses = OpenSRF::AppSession->create('open-ils.storage');
3082     $ses->request('open-ils.storage.action.hold_request.copy_targeter', undef, $self->retarget);
3083     # no reason to wait for the return value
3084     return;
3085 }
3086
3087 sub checkin_build_hold_transit {
3088     my $self = shift;
3089
3090    my $copy = $self->copy;
3091    my $hold = $self->hold;
3092    my $trans = Fieldmapper::action::hold_transit_copy->new;
3093
3094     $logger->debug("circulator: building hold transit for ".$copy->barcode);
3095
3096    $trans->hold($hold->id);
3097    $trans->source($self->circ_lib);
3098    $trans->dest($hold->pickup_lib);
3099    $trans->source_send_time("now");
3100    $trans->target_copy($copy->id);
3101
3102     # when the copy gets to its destination, it will recover
3103     # this status - put it onto the holds shelf
3104    $trans->copy_status(OILS_COPY_STATUS_ON_HOLDS_SHELF);
3105
3106     return $self->bail_on_events($self->editor->event)
3107         unless $self->editor->create_action_hold_transit_copy($trans);
3108 }
3109
3110
3111
3112 sub process_received_transit {
3113     my $self = shift;
3114     my $copy = $self->copy;
3115     my $copyid = $self->copy->id;
3116
3117     my $status_name = $U->copy_status($copy->status)->name;
3118     $logger->debug("circulator: attempting transit receive on ".
3119         "copy $copyid. Copy status is $status_name");
3120
3121     my $transit = $self->transit;
3122
3123     # Check if we are in a transit suppress range
3124     my $suppress_transit = 0;
3125     if ( $transit->dest != $self->circ_lib and not ( $self->hold_as_transit and $transit->copy_status == OILS_COPY_STATUS_ON_HOLDS_SHELF ) ) {
3126         my $suppress_setting = ($transit->copy_status == OILS_COPY_STATUS_ON_HOLDS_SHELF ?  'circ.transit.suppress_hold' : 'circ.transit.suppress_non_hold');
3127         my $suppress_transit_circ = $U->ou_ancestor_setting($self->circ_lib, $suppress_setting);
3128         if($suppress_transit_circ && $suppress_transit_circ->{value}) {
3129             my $suppress_transit_dest = $U->ou_ancestor_setting($transit->dest, $suppress_setting);
3130             if($suppress_transit_dest && $suppress_transit_dest->{value} eq $suppress_transit_circ->{value}) {
3131                 $suppress_transit = 1;
3132                 $self->fake_hold_dest(1) if $transit->copy_status == OILS_COPY_STATUS_ON_HOLDS_SHELF;
3133             }
3134         }
3135     }
3136     if( not $suppress_transit and ( $transit->dest != $self->circ_lib or ($self->hold_as_transit && $transit->copy_status == OILS_COPY_STATUS_ON_HOLDS_SHELF) ) ) {
3137         # - this item is in-transit to a different location
3138         # - Or we are capturing holds as transits, so why create a new transit?
3139
3140         my $tid = $transit->id;
3141         my $loc = $self->circ_lib;
3142         my $dest = $transit->dest;
3143
3144         $logger->info("circulator: Fowarding transit on copy which is destined ".
3145             "for a different location. transit=$tid, copy=$copyid, current ".
3146             "location=$loc, destination location=$dest");
3147
3148         my $evt = OpenILS::Event->new('ROUTE_ITEM', org => $dest, payload => {});
3149
3150         # grab the associated hold object if available
3151         my $ht = $self->editor->retrieve_action_hold_transit_copy($tid);
3152         $self->hold($self->editor->retrieve_action_hold_request($ht->hold)) if $ht;
3153
3154         return $self->bail_on_events($evt);
3155     }
3156
3157     # The transit is received, set the receive time
3158     $transit->dest_recv_time('now');
3159     $self->bail_on_events($self->editor->event)
3160         unless $self->editor->update_action_transit_copy($transit);
3161
3162     my $hold_transit = $self->editor->retrieve_action_hold_transit_copy($transit->id);
3163
3164     $logger->info("circulator: Recovering original copy status in transit: ".$transit->copy_status);
3165     $copy->status( $transit->copy_status );
3166     $self->update_copy();
3167     return if $self->bail_out;
3168
3169     my $ishold = 0;
3170     if($hold_transit) {
3171         my $hold = $self->editor->retrieve_action_hold_request($hold_transit->hold);
3172
3173         if ($hold) {
3174             # hold has arrived at destination, set shelf time
3175             $self->put_hold_on_shelf($hold);
3176             $self->bail_on_events($self->editor->event)
3177                 unless $self->editor->update_action_hold_request($hold);
3178             return if $self->bail_out;
3179
3180             $self->notify_hold($hold_transit->hold);
3181             $ishold = 1;
3182         } else {
3183             $hold_transit = undef;
3184             $self->cancelled_hold_transit(1);
3185             $self->reshelve_copy(1);
3186             $self->fake_hold_dest(0);
3187         }
3188     }
3189
3190     $self->push_events(
3191         OpenILS::Event->new(
3192         'SUCCESS',
3193         ishold => $ishold,
3194       payload => { transit => $transit, holdtransit => $hold_transit } ));
3195
3196     return $hold_transit;
3197 }
3198
3199
3200 # ------------------------------------------------------------------
3201 # Sets the shelf_time and shelf_expire_time for a newly shelved hold
3202 # ------------------------------------------------------------------
3203 sub put_hold_on_shelf {
3204     my($self, $hold) = @_;
3205     $hold->shelf_time('now');
3206     $hold->current_shelf_lib($self->circ_lib);
3207     $holdcode->set_hold_shelf_expire_time($hold, $self->editor);
3208     return undef;
3209 }
3210
3211 sub handle_fines {
3212    my $self = shift;
3213    my $reservation = shift;
3214    my $dt_parser = DateTime::Format::ISO8601->new;
3215
3216    my $obj = $reservation ? $self->reservation : $self->circ;
3217
3218     my $lost_bill_opts = $self->lost_bill_options;
3219     my $circ_lib = $lost_bill_opts->{circ_lib} if $lost_bill_opts;
3220     # first, restore any voided overdues for lost, if needed
3221     if ($self->needs_lost_bill_handling and !$self->void_overdues) {
3222         my $restore_od = $U->ou_ancestor_setting_value(
3223             $circ_lib, $lost_bill_opts->{ous_restore_overdue},
3224             $self->editor) || 0;
3225         $self->checkin_handle_lost_or_lo_now_found_restore_od($circ_lib)
3226             if $restore_od;
3227     }
3228
3229     # next, handle normal overdue generation and apply stop_fines
3230     # XXX reservations don't have stop_fines
3231     # TODO revisit booking_reservation re: stop_fines support
3232     if ($reservation or !$obj->stop_fines) {
3233         my $skip_for_grace;
3234
3235         # This is a crude check for whether we are in a grace period. The code
3236         # in generate_fines() does a more thorough job, so this exists solely
3237         # as a small optimization, and might be better off removed.
3238
3239         # If we have a grace period
3240         if($obj->can('grace_period')) {
3241             # Parse out the due date
3242             my $due_date = $dt_parser->parse_datetime( cleanse_ISO8601($obj->due_date) );
3243             # Add the grace period to the due date
3244             $due_date->add(seconds => OpenSRF::Utils->interval_to_seconds($obj->grace_period));
3245             # Don't generate fines on circs still in grace period
3246             $skip_for_grace = $due_date > DateTime->now;
3247         }
3248         $CC->generate_fines({circs => [$obj], editor => $self->editor})
3249             unless $skip_for_grace;
3250
3251         if (!$reservation and !$obj->stop_fines) {
3252             $obj->stop_fines(OILS_STOP_FINES_CHECKIN);
3253             $obj->stop_fines(OILS_STOP_FINES_RENEW) if $self->is_renewal;
3254             $obj->stop_fines(OILS_STOP_FINES_CLAIMS_NEVERCHECKEDOUT) if $self->claims_never_checked_out;
3255             $obj->stop_fines_time('now');
3256             $obj->stop_fines_time($self->backdate) if $self->backdate;
3257             $self->editor->update_action_circulation($obj);
3258         }
3259     }
3260
3261     # finally, handle voiding of lost item and processing fees
3262     if ($self->needs_lost_bill_handling) {
3263         my $void_cost = $U->ou_ancestor_setting_value(
3264             $circ_lib, $lost_bill_opts->{ous_void_item_cost},
3265             $self->editor) || 0;
3266         my $void_proc_fee = $U->ou_ancestor_setting_value(
3267             $circ_lib, $lost_bill_opts->{ous_void_proc_fee},
3268             $self->editor) || 0;
3269         $self->checkin_handle_lost_or_lo_now_found(
3270             $lost_bill_opts->{void_cost_btype},
3271             $lost_bill_opts->{is_longoverdue}) if $void_cost;
3272         $self->checkin_handle_lost_or_lo_now_found(
3273             $lost_bill_opts->{void_fee_btype},
3274             $lost_bill_opts->{is_longoverdue}) if $void_proc_fee;
3275     }
3276
3277    return undef;
3278 }
3279
3280 sub checkin_handle_circ_start {
3281    my $self = shift;
3282    my $circ = $self->circ;
3283    my $copy = $self->copy;
3284    my $evt;
3285    my $obt;
3286
3287    $self->backdate($circ->xact_start) if $self->claims_never_checked_out;
3288
3289    # backdate the circ if necessary
3290    if($self->backdate) {
3291         my $evt = $self->checkin_handle_backdate;
3292         return $self->bail_on_events($evt) if $evt;
3293    }
3294
3295     # Set the checkin vars since we have the item
3296     $circ->checkin_time( ($self->backdate) ? $self->backdate : 'now' );
3297
3298     # capture the true scan time for back-dated checkins
3299     $circ->checkin_scan_time('now');
3300
3301     $circ->checkin_staff($self->editor->requestor->id);
3302     $circ->checkin_lib($self->circ_lib);
3303     $circ->checkin_workstation($self->editor->requestor->wsid);
3304
3305     my $circ_lib = (ref $self->copy->circ_lib) ?
3306         $self->copy->circ_lib->id : $self->copy->circ_lib;
3307     my $stat = $U->copy_status($self->copy->status)->id;
3308
3309     if ($stat == OILS_COPY_STATUS_LOST || $stat == OILS_COPY_STATUS_LOST_AND_PAID) {
3310         # we will now handle lost fines, but the copy will retain its 'lost'
3311         # status if it needs to transit home unless lost_immediately_available
3312         # is true
3313         #
3314         # if we decide to also delay fine handling until the item arrives home,
3315         # we will need to call lost fine handling code both when checking items
3316         # in and also when receiving transits
3317         $self->checkin_handle_lost($circ_lib);
3318     } elsif ($stat == OILS_COPY_STATUS_LONG_OVERDUE) {
3319         # same process as above.
3320         $self->checkin_handle_long_overdue($circ_lib);
3321     } elsif ($circ_lib != $self->circ_lib and $stat == OILS_COPY_STATUS_MISSING) {
3322         $logger->info("circulator: not updating copy status on checkin because copy is missing");
3323     } else {
3324         $self->copy->status($U->copy_status(OILS_COPY_STATUS_RESHELVING));
3325         $self->update_copy;
3326     }
3327
3328     return undef;
3329 }
3330
3331 sub checkin_handle_circ_finish {
3332     my $self = shift;
3333     my $circ = $self->circ;
3334
3335     # see if there are any fines owed on this circ.  if not, close it
3336     my ($obt) = $U->fetch_mbts($circ->id, $self->editor);
3337     $circ->xact_finish('now') if( $obt and $obt->balance_owed == 0 );
3338
3339     $logger->debug("circulator: ".$obt->balance_owed." is owed on this circulation");
3340
3341     return $self->bail_on_events($self->editor->event)
3342         unless $self->editor->update_action_circulation($circ);
3343
3344     return undef;
3345 }
3346
3347 # ------------------------------------------------------------------
3348 # See if we need to void billings, etc. for lost checkin
3349 # ------------------------------------------------------------------
3350 sub checkin_handle_lost {
3351     my $self = shift;
3352     my $circ_lib = shift;
3353
3354     my $max_return = $U->ou_ancestor_setting_value($circ_lib,
3355         OILS_SETTING_MAX_ACCEPT_RETURN_OF_LOST, $self->editor) || 0;
3356
3357     $self->lost_bill_options({
3358         circ_lib => $circ_lib,
3359         ous_void_item_cost => OILS_SETTING_VOID_LOST_ON_CHECKIN,
3360         ous_void_proc_fee => OILS_SETTING_VOID_LOST_PROCESS_FEE_ON_CHECKIN,
3361         ous_restore_overdue => OILS_SETTING_RESTORE_OVERDUE_ON_LOST_RETURN,
3362         void_cost_btype => 3,
3363         void_fee_btype => 4
3364     });
3365
3366     return $self->checkin_handle_lost_or_longoverdue(
3367         circ_lib => $circ_lib,
3368         max_return => $max_return,
3369         ous_immediately_available => OILS_SETTING_LOST_IMMEDIATELY_AVAILABLE,
3370         ous_use_last_activity => undef # not supported for LOST checkin
3371     );
3372 }
3373
3374 # ------------------------------------------------------------------
3375 # See if we need to void billings, etc. for long-overdue checkin
3376 # note: not using constants below since they serve little purpose
3377 # for single-use strings that are descriptive in their own right
3378 # and mostly just complicate debugging.
3379 # ------------------------------------------------------------------
3380 sub checkin_handle_long_overdue {
3381     my $self = shift;
3382     my $circ_lib = shift;
3383
3384     $logger->info("circulator: processing long-overdue checkin...");
3385
3386     my $max_return = $U->ou_ancestor_setting_value($circ_lib,
3387         'circ.max_accept_return_of_longoverdue', $self->editor) || 0;
3388
3389     $self->lost_bill_options({
3390         circ_lib => $circ_lib,
3391         ous_void_item_cost => 'circ.void_longoverdue_on_checkin',
3392         ous_void_proc_fee => 'circ.void_longoverdue_proc_fee_on_checkin',
3393         is_longoverdue => 1,
3394         ous_restore_overdue => 'circ.restore_overdue_on_longoverdue_return',
3395         void_cost_btype => 10,
3396         void_fee_btype => 11
3397     });
3398
3399     return $self->checkin_handle_lost_or_longoverdue(
3400         circ_lib => $circ_lib,
3401         max_return => $max_return,
3402         ous_immediately_available => 'circ.longoverdue_immediately_available',
3403         ous_use_last_activity =>
3404             'circ.longoverdue.use_last_activity_date_on_return'
3405     )
3406 }
3407
3408 # last billing activity is last payment time, last billing time, or the
3409 # circ due date.  If the relevant "use last activity" org unit setting is
3410 # false/unset, then last billing activity is always the due date.
3411 sub get_circ_last_billing_activity {
3412     my $self = shift;
3413     my $circ_lib = shift;
3414     my $setting = shift;
3415     my $date = $self->circ->due_date;
3416
3417     return $date unless $setting and
3418         $U->ou_ancestor_setting_value($circ_lib, $setting, $self->editor);
3419
3420     my $xact = $self->editor->retrieve_money_billable_transaction([
3421         $self->circ->id,
3422         {flesh => 1, flesh_fields => {mbt => ['summary']}}
3423     ]);
3424
3425     if ($xact->summary) {
3426         $date = $xact->summary->last_payment_ts ||
3427                 $xact->summary->last_billing_ts ||
3428                 $self->circ->due_date;
3429     }
3430
3431     return $date;
3432 }
3433
3434
3435 sub checkin_handle_lost_or_longoverdue {
3436     my ($self, %args) = @_;
3437
3438     my $circ = $self->circ;
3439     my $max_return = $args{max_return};
3440     my $circ_lib = $args{circ_lib};
3441
3442     if ($max_return) {
3443
3444         my $last_activity =
3445             $self->get_circ_last_billing_activity(
3446                 $circ_lib, $args{ous_use_last_activity});
3447
3448         my $today = time();
3449         my @tm = reverse($last_activity =~ /([\d\.]+)/og);
3450         $tm[5] -= 1 if $tm[5] > 0;
3451         my $due = timelocal(int($tm[1]), int($tm[2]),
3452             int($tm[3]), int($tm[4]), int($tm[5]), int($tm[6]));
3453
3454         my $last_chance =
3455             OpenSRF::Utils->interval_to_seconds($max_return) + int($due);
3456
3457         $logger->info("MAX OD: $max_return LAST ACTIVITY: ".
3458             "$last_activity DUEDATE: ".$circ->due_date." TODAY: $today ".
3459                 "DUE: $due LAST: $last_chance");
3460
3461         $max_return = 0 if $today < $last_chance;
3462     }
3463
3464
3465     if ($max_return) {
3466
3467         $logger->info("circulator: check-in of lost/lo item exceeds max ".
3468             "return interval.  skipping fine/fee voiding, etc.");
3469
3470     } elsif ($self->dont_change_lost_zero) { # we leave lost zero balance alone
3471
3472         $logger->info("circulator: check-in of lost/lo item having a balance ".
3473             "of zero, skipping fine/fee voiding and reinstatement.");
3474
3475     } else { # within max-return interval or no interval defined
3476
3477         $logger->info("circulator: check-in of lost/lo item is within the ".
3478             "max return interval (or no interval is defined).  Proceeding ".
3479             "with fine/fee voiding, etc.");
3480
3481         $self->needs_lost_bill_handling(1);
3482     }
3483
3484     if ($circ_lib != $self->circ_lib) {
3485         # if the item is not home, check to see if we want to retain the
3486         # lost/longoverdue status at this point in the process
3487
3488         my $immediately_available = $U->ou_ancestor_setting_value($circ_lib,
3489             $args{ous_immediately_available}, $self->editor) || 0;
3490
3491         if ($immediately_available) {
3492             # item status does not need to be retained, so give it a
3493             # reshelving status as if it were a normal checkin
3494             $self->copy->status($U->copy_status(OILS_COPY_STATUS_RESHELVING));
3495             $self->update_copy;
3496         } else {
3497             $logger->info("circulator: leaving lost/longoverdue copy".
3498                 " status in place on checkin");
3499         }
3500     } else {
3501         # lost/longoverdue item is home and processed, treat like a normal
3502         # checkin from this point on
3503         $self->copy->status($U->copy_status(OILS_COPY_STATUS_RESHELVING));
3504         $self->update_copy;
3505     }
3506 }
3507
3508
3509 sub checkin_handle_backdate {
3510     my $self = shift;
3511
3512     # ------------------------------------------------------------------
3513     # clean up the backdate for date comparison
3514     # XXX We are currently taking the due-time from the original due-date,
3515     # not the input.  Do we need to do this?  This certainly interferes with
3516     # backdating of hourly checkouts, but that is likely a very rare case.
3517     # ------------------------------------------------------------------
3518     my $bd = cleanse_ISO8601($self->backdate);
3519     my $original_date = DateTime::Format::ISO8601->new->parse_datetime(cleanse_ISO8601($self->circ->due_date));
3520     my $new_date = DateTime::Format::ISO8601->new->parse_datetime($bd);
3521     $new_date->set_hour($original_date->hour());
3522     $new_date->set_minute($original_date->minute());
3523     if ($new_date >= DateTime->now) {
3524         # We can't say that the item will be checked in later...so assume someone's clock is wrong instead.
3525         # $self->backdate() autoload handler ignores undef values.
3526         # Clear the backdate manually.
3527         $logger->info("circulator: ignoring future backdate: $new_date");
3528         delete $self->{backdate};
3529     } else {
3530         $self->backdate(cleanse_ISO8601($new_date->datetime()));
3531     }
3532
3533     return undef;
3534 }
3535
3536
3537 sub check_checkin_copy_status {
3538     my $self = shift;
3539    my $copy = $self->copy;
3540
3541    my $status = $U->copy_status($copy->status)->id;
3542
3543    return undef
3544       if(   $status == OILS_COPY_STATUS_AVAILABLE   ||
3545             $status == OILS_COPY_STATUS_CHECKED_OUT ||
3546             $status == OILS_COPY_STATUS_IN_PROCESS  ||
3547             $status == OILS_COPY_STATUS_ON_HOLDS_SHELF  ||
3548             $status == OILS_COPY_STATUS_IN_TRANSIT  ||
3549             $status == OILS_COPY_STATUS_CATALOGING  ||
3550             $status == OILS_COPY_STATUS_ON_RESV_SHELF  ||
3551             $status == OILS_COPY_STATUS_CANCELED_TRANSIT ||
3552             $status == OILS_COPY_STATUS_RESHELVING );
3553
3554    return OpenILS::Event->new('COPY_STATUS_LOST', payload => $copy )
3555       if( $status == OILS_COPY_STATUS_LOST );
3556
3557     return OpenILS::Event->new('COPY_STATUS_LOST_AND_PAID', payload => $copy)
3558         if ($status == OILS_COPY_STATUS_LOST_AND_PAID);
3559
3560    return OpenILS::Event->new('COPY_STATUS_LONG_OVERDUE', payload => $copy )
3561       if( $status == OILS_COPY_STATUS_LONG_OVERDUE );
3562
3563    return OpenILS::Event->new('COPY_STATUS_MISSING', payload => $copy )
3564       if( $status == OILS_COPY_STATUS_MISSING );
3565
3566    return OpenILS::Event->new('COPY_BAD_STATUS', payload => $copy );
3567 }
3568
3569
3570
3571 # --------------------------------------------------------------------------
3572 # On checkin, we need to return as many relevant objects as we can
3573 # --------------------------------------------------------------------------
3574 sub checkin_flesh_events {
3575     my $self = shift;
3576
3577     if( grep { $_->{textcode} eq 'SUCCESS' } @{$self->events}
3578         and grep { $_->{textcode} eq 'ITEM_NOT_CATALOGED' } @{$self->events} ) {
3579             $self->events([grep { $_->{textcode} eq 'ITEM_NOT_CATALOGED' } @{$self->events}]);
3580     }
3581
3582     my $record = $U->record_to_mvr($self->title) if($self->title and !$self->is_precat);
3583
3584     my $hold;
3585     if($self->hold and !$self->hold->cancel_time) {
3586         $hold = $self->hold;
3587         $hold->notes($self->editor->search_action_hold_request_note({hold => $hold->id}));
3588     }
3589
3590     if($self->circ) {
3591         # update our copy of the circ object and
3592         # flesh the billing summary data
3593         $self->circ(
3594             $self->editor->retrieve_action_circulation([
3595                 $self->circ->id, {
3596                     flesh => 2,
3597                     flesh_fields => {
3598                         circ => ['billable_transaction'],
3599                         mbt => ['summary']
3600                     }
3601                 }
3602             ])
3603         );
3604     }
3605
3606     if($self->patron) {
3607         # flesh some patron fields before returning
3608         $self->patron(
3609             $self->editor->retrieve_actor_user([
3610                 $self->patron->id,
3611                 {
3612                     flesh => 1,
3613                     flesh_fields => {
3614                         au => ['card', 'billing_address', 'mailing_address']
3615                     }
3616                 }
3617             ])
3618         );
3619     }
3620
3621     for my $evt (@{$self->events}) {
3622
3623         my $payload         = {};
3624         $payload->{copy}    = $U->unflesh_copy($self->copy);
3625         $payload->{volume}  = $self->volume;
3626         $payload->{record}  = $record,
3627         $payload->{circ}    = $self->circ;
3628         $payload->{transit} = $self->transit;
3629         $payload->{cancelled_hold_transit} = 1 if $self->cancelled_hold_transit;
3630         $payload->{hold}    = $hold;
3631         $payload->{patron}  = $self->patron;
3632         $payload->{reservation} = $self->reservation
3633             unless (not $self->reservation or $self->reservation->cancel_time);
3634
3635         $evt->{payload}     = $payload;
3636     }
3637 }
3638
3639 sub log_me {
3640     my( $self, $msg ) = @_;
3641     my $bc = ($self->copy) ? $self->copy->barcode :
3642         $self->barcode;
3643     $bc ||= "";
3644     my $usr = ($self->patron) ? $self->patron->id : "";
3645     $logger->info("circulator: $msg requestor=".$self->editor->requestor->id.
3646         ", recipient=$usr, copy=$bc");
3647 }
3648
3649
3650 sub do_renew {
3651     my $self = shift;
3652     $self->log_me("do_renew()");
3653
3654     # Make sure there is an open circ to renew
3655     my $usrid = $self->patron->id if $self->patron;
3656     my $circ = $self->editor->search_action_circulation({
3657         target_copy => $self->copy->id,
3658         xact_finish => undef,
3659         checkin_time => undef,
3660         ($usrid ? (usr => $usrid) : ())
3661     })->[0];
3662
3663     return $self->bail_on_events($self->editor->event) unless $circ;
3664
3665     # A user is not allowed to renew another user's items without permission
3666     unless( $circ->usr eq $self->editor->requestor->id ) {
3667         return $self->bail_on_events($self->editor->events)
3668             unless $self->editor->allowed('RENEW_CIRC', $circ->circ_lib);
3669     }
3670
3671     $self->push_events(OpenILS::Event->new('MAX_RENEWALS_REACHED'))
3672         if $circ->renewal_remaining < 1;
3673
3674     # -----------------------------------------------------------------
3675
3676     $self->parent_circ($circ->id);
3677     $self->renewal_remaining( $circ->renewal_remaining - 1 );
3678     $self->circ($circ);
3679
3680     # Opac renewal - re-use circ library from original circ (unless told not to)
3681     if($self->opac_renewal) {
3682         unless(defined($opac_renewal_use_circ_lib)) {
3683             my $use_circ_lib = $self->editor->retrieve_config_global_flag('circ.opac_renewal.use_original_circ_lib');
3684             if($use_circ_lib and $U->is_true($use_circ_lib->enabled)) {
3685                 $opac_renewal_use_circ_lib = 1;
3686             }
3687             else {
3688                 $opac_renewal_use_circ_lib = 0;
3689             }
3690         }
3691         $self->circ_lib($circ->circ_lib) if($opac_renewal_use_circ_lib);
3692     }
3693
3694     # Desk renewal - re-use circ library from original circ (unless told not to)
3695     if($self->desk_renewal) {
3696         unless(defined($desk_renewal_use_circ_lib)) {
3697             my $use_circ_lib = $self->editor->retrieve_config_global_flag('circ.desk_renewal.use_original_circ_lib');
3698             if($use_circ_lib and $U->is_true($use_circ_lib->enabled)) {
3699                 $desk_renewal_use_circ_lib = 1;
3700             }
3701             else {
3702                 $desk_renewal_use_circ_lib = 0;
3703             }
3704         }
3705         $self->circ_lib($circ->circ_lib) if($desk_renewal_use_circ_lib);
3706     }
3707
3708     # Run the fine generator against the old circ
3709     # XXX This seems unnecessary, given that handle_fines runs in do_checkin
3710     # a few lines down.  Commenting out, for now.
3711     #$self->handle_fines;
3712
3713     $self->run_renew_permit;
3714
3715     # Check the item in
3716     $self->do_checkin();
3717     return if $self->bail_out;
3718
3719     unless( $self->permit_override ) {
3720         $self->do_permit();
3721         return if $self->bail_out;
3722         $self->is_precat(1) if $self->have_event('ITEM_NOT_CATALOGED');
3723         $self->remove_event('ITEM_NOT_CATALOGED');
3724     }
3725
3726     $self->override_events;
3727     return if $self->bail_out;
3728
3729     $self->events([]);
3730     $self->do_checkout();
3731 }
3732
3733
3734 sub remove_event {
3735     my( $self, $evt ) = @_;
3736     $evt = (ref $evt) ? $evt->{textcode} : $evt;
3737     $logger->debug("circulator: removing event from list: $evt");
3738     my @events = @{$self->events};
3739     $self->events( [ grep { $_->{textcode} ne $evt } @events ] );
3740 }
3741
3742
3743 sub have_event {
3744     my( $self, $evt ) = @_;
3745     $evt = (ref $evt) ? $evt->{textcode} : $evt;
3746     return grep { $_->{textcode} eq $evt } @{$self->events};
3747 }
3748
3749
3750 sub run_renew_permit {
3751     my $self = shift;
3752
3753     if ($U->ou_ancestor_setting_value($self->circ_lib, 'circ.block_renews_for_holds')) {
3754         my ($hold, undef, $retarget) = $holdcode->find_nearest_permitted_hold(
3755             $self->editor, $self->copy, $self->editor->requestor, 1
3756         );
3757         $self->push_events(new OpenILS::Event("COPY_NEEDED_FOR_HOLD")) if $hold;
3758     }
3759
3760     my $results = $self->run_indb_circ_test;
3761     $self->push_events($self->matrix_test_result_events)
3762         unless $self->circ_test_success;
3763 }
3764
3765
3766 # XXX: The primary mechanism for storing circ history is now handled
3767 # by tracking real circulation objects instead of bibs in a bucket.
3768 # However, this code is disabled by default and could be useful
3769 # some day, so may as well leave it for now.
3770 sub append_reading_list {
3771     my $self = shift;
3772
3773     return undef unless
3774         $self->is_checkout and
3775         $self->patron and
3776         $self->copy and
3777         !$self->is_noncat;
3778
3779
3780     # verify history is globally enabled and uses the bucket mechanism
3781     my $htype = OpenSRF::Utils::SettingsClient->new->config_value(
3782         apps => 'open-ils.circ' => app_settings => 'checkout_history_mechanism');
3783
3784     return undef unless $htype and $htype eq 'bucket';
3785
3786     my $e = new_editor(xact => 1, requestor => $self->editor->requestor);
3787
3788     # verify the patron wants to retain the hisory
3789     my $setting = $e->search_actor_user_setting(
3790         {usr => $self->patron->id, name => 'circ.keep_checkout_history'})->[0];
3791
3792     unless($setting and $setting->value) {
3793         $e->rollback;
3794         return undef;
3795     }
3796
3797     my $bkt = $e->search_container_copy_bucket(
3798         {owner => $self->patron->id, btype => 'circ_history'})->[0];
3799
3800     my $pos = 1;
3801
3802     if($bkt) {
3803         # find the next item position
3804         my $last_item = $e->search_container_copy_bucket_item(
3805             {bucket => $bkt->id}, {order_by => {ccbi => 'pos desc'}, limit => 1})->[0];
3806         $pos = $last_item->pos + 1 if $last_item;
3807
3808     } else {
3809         # create the history bucket if necessary
3810         $bkt = Fieldmapper::container::copy_bucket->new;
3811         $bkt->owner($self->patron->id);
3812         $bkt->name('');
3813         $bkt->btype('circ_history');
3814         $bkt->pub('f');
3815         $e->create_container_copy_bucket($bkt) or return $e->die_event;
3816     }
3817
3818     my $item = Fieldmapper::container::copy_bucket_item->new;
3819
3820     $item->bucket($bkt->id);
3821     $item->target_copy($self->copy->id);
3822     $item->pos($pos);
3823
3824     $e->create_container_copy_bucket_item($item) or return $e->die_event;
3825     $e->commit;
3826
3827     return undef;
3828 }
3829
3830
3831 sub make_trigger_events {
3832     my $self = shift;
3833     return unless $self->circ;
3834     $U->create_events_for_hook('checkout', $self->circ, $self->circ_lib) if $self->is_checkout;
3835     $U->create_events_for_hook('checkin',  $self->circ, $self->circ_lib) if $self->is_checkin;
3836     $U->create_events_for_hook('renewal',  $self->circ, $self->circ_lib) if $self->is_renewal;
3837 }
3838
3839
3840
3841 sub checkin_handle_lost_or_lo_now_found {
3842     my ($self, $bill_type, $is_longoverdue) = @_;
3843
3844     my $tag = $is_longoverdue ? "LONGOVERDUE" : "LOST";
3845
3846     $logger->debug("voiding $tag item billings");
3847     my $result = $CC->void_or_zero_bills_of_type($self->editor, $self->circ, $self->copy, $bill_type, "$tag ITEM RETURNED");
3848     $self->bail_on_events($self->editor->event) if ($result);
3849 }
3850
3851 sub checkin_handle_lost_or_lo_now_found_restore_od {
3852     my $self = shift;
3853     my $circ_lib = shift;
3854     my $is_longoverdue = shift;
3855     my $tag = $is_longoverdue ? "LONGOVERDUE" : "LOST";
3856
3857     # ------------------------------------------------------------------
3858     # restore those overdue charges voided when item was set to lost
3859     # ------------------------------------------------------------------
3860
3861     my $ods = $self->editor->search_money_billing([
3862         {
3863             xact => $self->circ->id,
3864             btype => 1
3865         },
3866         {
3867             order_by => {mb => 'billing_ts desc'}
3868         }
3869     ]);
3870
3871     $logger->debug("returning ".scalar(@$ods)." overdue charges pre-$tag");
3872     # Because actual users get up to all kinds of unexpectedness, we
3873     # only recreate up to $circ->max_fine in bills.  I know you think
3874     # it wouldn't happen that bills could get created, voided, and
3875     # recreated more than once, but I guaran-damn-tee you that it will
3876     # happen.
3877     if ($ods && @$ods) {
3878         my $void_amount = 0;
3879         my $void_max = $self->circ->max_fine();
3880         # search for overdues voided the new way (aka "adjusted")
3881         my @billings = map {$_->id()} @$ods;
3882         my $voids = $self->editor->search_money_account_adjustment(
3883             {
3884                 billing => \@billings
3885             }
3886         );
3887         if (@$voids) {
3888             map {$void_amount += $_->amount()} @$voids;
3889         } else {
3890             # if no adjustments found, assume they were voided the old way (aka "voided")
3891             for my $bill (@$ods) {
3892                 if( $U->is_true($bill->voided) ) {
3893                     $void_amount += $bill->amount();
3894                 }
3895             }
3896         }
3897         $CC->create_bill(
3898             $self->editor,
3899             ($void_amount < $void_max ? $void_amount : $void_max),
3900             $ods->[0]->btype(),
3901             $ods->[0]->billing_type(),
3902             $self->circ->id(),
3903             "System: $tag RETURNED - OVERDUES REINSTATED",
3904             $ods->[0]->billing_ts() # date this restoration the same as the last overdue (for possible subsequent fine generation)
3905         );
3906     }
3907 }
3908
3909 1;