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

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