Open-ILS/src/perlmods/lib/OpenILS/Application/Circ/Circulate.pm

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