Open-ILS/src/perlmods/lib/OpenILS/SIP.pm

   1 #
   2 # ILS.pm: Test ILS interface module
   3 #
   4
   5 package OpenILS::SIP;
   6 use warnings; use strict;
   7
   8 use Sys::Syslog qw(syslog);
   9 use Time::HiRes q/time/;
  10
  11 use OpenILS::SIP::Item;
  12 use OpenILS::SIP::Patron;
  13 use OpenILS::SIP::Transaction;
  14 use OpenILS::SIP::Transaction::Checkout;
  15 use OpenILS::SIP::Transaction::Checkin;
  16 use OpenILS::SIP::Transaction::Renew;
  17 use OpenILS::SIP::Transaction::FeePayment;
  18
  19 use OpenSRF::System;
  20 use OpenSRF::AppSession;
  21 use OpenILS::Utils::Fieldmapper;
  22 use OpenSRF::Utils::SettingsClient;
  23 use OpenILS::Application::AppUtils;
  24 use OpenSRF::Utils qw/:datetime/;
  25 use DateTime::Format::ISO8601;
  26 use Encode;
  27 use Unicode::Normalize;
  28 my $U = 'OpenILS::Application::AppUtils';
  29
  30 my $editor;
  31 my $config;
  32 my $login_account;
  33 my $target_encoding;    # FIXME: this is configured at the institution level.
  34
  35 use Digest::MD5 qw(md5_hex);
  36
  37 sub new {
  38     my ($class, $institution, $login) = @_;
  39     my $type = ref($class) || $class;
  40     my $self = {};
  41
  42     $self->{login} = $login_account = $login;
  43
  44     $config = $institution;
  45     syslog("LOG_DEBUG", "OILS: new ILS '%s'", $institution->{id});
  46     $self->{institution} = $institution;
  47
  48     my $bsconfig     = $institution->{implementation_config}->{bootstrap};
  49     $target_encoding = $institution->{implementation_config}->{encoding} || 'ascii';
  50
  51     syslog('LOG_DEBUG', "OILS: loading bootstrap config: $bsconfig");
  52
  53     # ingress will persist throughout
  54     OpenSRF::AppSession->ingress('sip2');
  55
  56     local $/ = "\n";    # why?
  57     OpenSRF::System->bootstrap_client(config_file => $bsconfig);
  58     syslog('LOG_DEBUG', "OILS: bootstrap loaded..");
  59
  60     $self->{osrf_config} = OpenSRF::Utils::SettingsClient->new;
  61
  62     Fieldmapper->import($self->{osrf_config}->config_value('IDL'));
  63
  64     bless( $self, $type );
  65
  66     return undef unless
  67         $self->login( $login->{id}, $login->{password} );
  68
  69     return $self;
  70 }
  71
  72 sub fetch_session {
  73     my $self = shift;
  74
  75     my $ses = $U->simplereq(
  76         'open-ils.auth',
  77         'open-ils.auth.session.retrieve',  $self->{authtoken});
  78
  79     return undef if $U->event_code($ses); # auth timed out
  80     return $self->{login_session} = $ses;
  81 }
  82
  83 sub verify_session {
  84     my $self = shift;
  85
  86     return 1 if $self->fetch_session;
  87
  88     syslog('LOG_INFO', "OILS: Logging back after session timeout as user ".$self->{login}->{id});
  89     return $self->login( $self->{login}->{id}, $self->{login}->{password} );
  90 }
  91
  92 sub editor {
  93     return $editor = make_editor();
  94 }
  95
  96 sub config {
  97     return $config;
  98 }
  99 sub login_account {
 100     return $login_account;
 101 }
 102
 103 sub get_option_value {
 104     my($self, $option) = @_;
 105     my $ops = $config->{implementation_config}->{options}->{option};
 106     $ops = [$ops] unless ref $ops eq 'ARRAY';
 107     my @vals = grep { $_->{name} eq $option } @$ops;
 108     return @vals ? $vals[0]->{value} : undef;
 109 }
 110
 111
 112 # Creates the global editor object
 113 my $cstore_init = 1; # call init on first use
 114 sub make_editor {
 115     OpenILS::Utils::CStoreEditor::init() if $cstore_init;
 116     $cstore_init = 0;
 117     return OpenILS::Utils::CStoreEditor->new;
 118 }
 119
 120 =head2 clean_text(scalar)
 121
 122 Evergreen uses the UTF8 encoding for everything from the database up. Perl
 123 doesn't know this, however, so we have to convince it to treat our UTF8 strings
 124 as UTF8 strings. This may enable OpenNCIP to correctly calculate the checksums
 125 for UTF8 text for SIP clients that support such modern options.
 126
 127 The target encoding is set in the <encoding> element of the SIPServer.pm
 128 configuration file.
 129
 130 =cut
 131
 132 sub clean_text {
 133     my $text = shift || '';
 134
 135     # Convert our incoming UTF8 data into Perl's internal string format
 136
 137     # Also convert to Normalization Form D, as the ASCII, iso-8859-1,
 138     # and latin-1 encodings (at least) require this to substitute
 139     # characters rather than simply returning a string truncated
 140     # after the first non-ASCII character
 141     $text = NFD(decode_utf8($text));
 142
 143     if ($target_encoding eq 'ascii') {
 144
 145         # Try to maintain a reasonable version of the content by
 146         # stripping diacritics from the text, given that the SIP client
 147         # wants just plain ASCII. This is the base requirement according
 148         # to the SIP2 specification.
 149
 150         # Stripping the combining characters converts ""béè♁ts"
 151         # into "bee?ts" instead of "b???ts" - better, eh?
 152         $text =~ s/\pM+//og;
 153     }
 154
 155     # Characters that cannot be represented in the target encoding will
 156     # generally be replaced with a question mark (?) character.
 157     $text = encode($target_encoding, $text);
 158
 159     return $text;
 160 }
 161
 162 my %org_sn_cache;
 163 sub shortname_from_id {
 164     my $id = shift or return;
 165     return $id->shortname if ref $id;
 166     return $org_sn_cache{$id} if $org_sn_cache{$id};
 167     return $org_sn_cache{$id} = editor()->retrieve_actor_org_unit($id)->shortname;
 168 }
 169 sub patron_barcode_from_id {
 170     my $id = shift or return;
 171     return editor()->search_actor_card({ usr => $id, active => 't' })->[0]->barcode;
 172 }
 173
 174 sub format_date {
 175     my $class = shift;
 176     my $date = shift;
 177     my $type = shift || 'dob';
 178
 179     return "" unless $date;
 180
 181     $date = DateTime::Format::ISO8601->new->
 182         parse_datetime(OpenSRF::Utils::cleanse_ISO8601($date));
 183     my @time = localtime($date->epoch);
 184
 185     my $year   = $time[5]+1900;
 186     my $mon    = $time[4]+1;
 187     my $day    = $time[3];
 188     my $hour   = $time[2];
 189     my $minute = $time[1];
 190     my $second = $time[0];
 191
 192     $date = sprintf("%04d%02d%02d", $year, $mon, $day);
 193
 194     # Due dates need hyphen separators and time of day as well
 195     if ($type eq 'due') {
 196         $date = sprintf("%04d-%02d-%02d %02d:%02d:%02d", $year, $mon, $day, $hour, $minute, $second);
 197     }
 198
 199     syslog('LOG_DEBUG', "OILS: formatted date [type=$type]: $date");
 200     return $date;
 201 }
 202
 203
 204
 205 sub login {
 206     my( $self, $username, $password ) = @_;
 207     syslog('LOG_DEBUG', "OILS: Logging in with username $username");
 208
 209     my $seed = $U->simplereq(
 210         'open-ils.auth',
 211         'open-ils.auth.authenticate.init', $username );
 212
 213     my $response = $U->simplereq(
 214         'open-ils.auth',
 215         'open-ils.auth.authenticate.complete',
 216         {
 217             username => $username,
 218             password => md5_hex($seed . md5_hex($password)),
 219             type     => 'opac',
 220         }
 221     );
 222
 223     if( my $code = $U->event_code($response) ) {
 224         my $txt = $response->{textcode};
 225         syslog('LOG_WARNING', "OILS: Login failed for $username.  $txt:$code");
 226         return undef;
 227     }
 228
 229     my $key = $response->{payload}->{authtoken};
 230     syslog('LOG_INFO', "OILS: Login succeeded for $username : authkey = $key");
 231
 232     $self->fetch_session; # to cache the login
 233
 234     return $self->{authtoken} = $key;
 235 }
 236
 237 #
 238 # find_patron($barcode);
 239 # find_patron(barcode => $barcode);   # same as above
 240 # find_patron(usr => $id);
 241
 242 sub find_patron {
 243     my $self = shift;
 244     my $key  =  (@_ > 1) ? shift : 'barcode';  # if we have multiple args, the first is the key index (default barcode)
 245     my $patron_id = shift;
 246
 247     return OpenILS::SIP::Patron->new($key => $patron_id, authtoken => $self->{authtoken}, @_);
 248 }
 249
 250
 251 sub find_item {
 252     my $self = shift;
 253     return OpenILS::SIP::Item->new(@_);
 254 }
 255
 256
 257 sub institution {
 258     my $self = shift;
 259     return $self->{institution}->{id};  # consider making this return the whole institution
 260 }
 261
 262 sub institution_id {
 263     my $self = shift;
 264     return $self->{institution}->{id};  # then use this for just the ID
 265 }
 266
 267 sub supports {
 268     my ($self, $op) = @_;
 269     my ($i) = grep { $_->{name} eq $op }
 270         @{$config->{implementation_config}->{supports}->{item}};
 271     return to_bool($i->{value});
 272 }
 273
 274 sub check_inst_id {
 275     my ($self, $id, $whence) = @_;
 276     if ($id ne $self->{institution}->{id}) {
 277         syslog("LOG_WARNING", "OILS: %s: received institution '%s', expected '%s'", $whence, $id, $self->{institution}->{id});
 278         # Just an FYI check, we don't expect the user to change location from that in SIPconfig.xml
 279     }
 280 }
 281
 282
 283 sub to_bool {
 284     my $bool = shift;
 285     # If it's defined, and matches a true sort of string, or is
 286     # a non-zero number, then it's true.
 287     defined($bool) or return;                   # false
 288     ($bool =~ /true|y|yes/i) and return 1;      # true
 289     return ($bool =~ /^\d+$/ and $bool != 0);   # true for non-zero numbers, false otherwise
 290 }
 291
 292 sub checkout_ok {
 293     return to_bool($config->{policy}->{checkout});
 294 }
 295
 296 sub checkin_ok {
 297     return to_bool($config->{policy}->{checkin});
 298 }
 299
 300 sub renew_ok {
 301     return to_bool($config->{policy}->{renewal});
 302 }
 303
 304 sub status_update_ok {
 305     return to_bool($config->{policy}->{status_update});
 306 }
 307
 308 sub offline_ok {
 309     return to_bool($config->{policy}->{offline});
 310 }
 311
 312
 313
 314 ##
 315 ## Checkout(patron_id, item_id, sc_renew, fee_ack):
 316 ##    patron_id & item_id are the identifiers send by the terminal
 317 ##    sc_renew is the renewal policy configured on the terminal
 318 ## returns a status opject that can be queried for the various bits
 319 ## of information that the protocol (SIP or NCIP) needs to generate
 320 ## the response.
 321 ##    fee_ack is the fee_acknowledged field (BO) sent from the sc
 322 ## when doing chargeable loans.
 323 ##
 324
 325 sub checkout {
 326     my ($self, $patron_id, $item_id, $sc_renew, $fee_ack) = @_;
 327     # In order to allow renewals the selfcheck AND the config have to say they are allowed
 328     $sc_renew = (chr($sc_renew) eq 'Y' && $self->renew_ok());
 329
 330     $self->verify_session;
 331
 332     syslog('LOG_DEBUG', "OILS: OpenILS::Checkout attempt: patron=$patron_id, item=$item_id");
 333
 334     my $xact   = OpenILS::SIP::Transaction::Checkout->new( authtoken => $self->{authtoken} );
 335     my $patron = $self->find_patron($patron_id);
 336     my $item   = $self->find_item($item_id);
 337
 338     $xact->patron($patron);
 339     $xact->item($item);
 340
 341     if (!$patron) {
 342         $xact->screen_msg("Invalid Patron Barcode '$patron_id'");
 343         return $xact;
 344     }
 345
 346     if (!$patron->charge_ok) {
 347         $xact->screen_msg("Patron Blocked");
 348         return $xact;
 349     }
 350
 351     if( !$item ) {
 352         $xact->screen_msg("Invalid Item Barcode: '$item_id'");
 353         return $xact;
 354     }
 355
 356     syslog('LOG_DEBUG', "OILS: OpenILS::Checkout data loaded OK, checking out...");
 357
 358     if ($item->{patron} && ($item->{patron} eq $patron_id)) {
 359         $xact->renew_ok(1); # So that accept/reject responses have the correct value later
 360         if($sc_renew) {
 361             syslog('LOG_INFO', "OILS: OpenILS::Checkout data loaded OK, doing renew...");
 362         } else {
 363             syslog('LOG_INFO', "OILS: OpenILS::Checkout appears to be renew, but renewal disallowed...");
 364             $xact->screen_msg("Renewals not permitted");
 365             $xact->ok(0);
 366             return $xact; # Don't attempt later
 367         }
 368     } elsif ($item->{patron} && ($item->{patron} ne $patron_id)) {
 369         # I can't deal with this right now
 370         # XXX check in then check out?
 371         $xact->screen_msg("Item checked out to another patron");
 372         $xact->ok(0);
 373         return $xact; # Don't wipe out the screen message later
 374     } else {
 375         $sc_renew = 0;
 376     }
 377
 378     # Check for fee and $fee_ack. If there is a fee, and $fee_ack
 379     # is 'Y', we proceed, otherwise we reject the checkout.
 380     if ($item->fee > 0.0) {
 381         $xact->fee_amount($item->fee);
 382         $xact->sip_fee_type($item->sip_fee_type);
 383         $xact->sip_currency($item->fee_currency);
 384         if ($fee_ack && $fee_ack eq 'Y') {
 385             $xact->fee_ack(1);
 386         } else {
 387             $xact->screen_msg('Fee required');
 388             $xact->ok(0);
 389             return $xact;
 390         }
 391     }
 392
 393     $xact->do_checkout($sc_renew);
 394     $xact->desensitize(!$item->magnetic);
 395
 396     if( $xact->ok ) {
 397         #editor()->commit;
 398         syslog("LOG_DEBUG", "OILS: OpenILS::Checkout: " .
 399             "patron %s checkout %s succeeded", $patron_id, $item_id);
 400     } else {
 401         #editor()->xact_rollback;
 402         syslog("LOG_DEBUG", "OILS: OpenILS::Checkout: " .
 403             "patron %s checkout %s FAILED, rolling back xact...", $patron_id, $item_id);
 404     }
 405
 406     return $xact;
 407 }
 408
 409
 410 sub checkin {
 411     my ($self, $item_id, $inst_id, $trans_date, $return_date,
 412         $current_loc, $item_props, $cancel) = @_;
 413
 414     my $start_time = time();
 415
 416     $self->verify_session;
 417
 418     syslog('LOG_DEBUG', "OILS: OpenILS::Checkin of item=$item_id (to $inst_id)");
 419
 420     my $xact = OpenILS::SIP::Transaction::Checkin->new(authtoken => $self->{authtoken});
 421     my $item = OpenILS::SIP::Item->new($item_id);
 422
 423     unless ( $xact->item($item) ) {
 424         $xact->ok(0);
 425         # $circ->alert(1); $circ->alert_type(99);
 426         $xact->screen_msg("Invalid Item Barcode: '$item_id'");
 427         syslog('LOG_INFO', "OILS: Checkin failed.  " . $xact->screen_msg() );
 428         return $xact;
 429     }
 430
 431     $xact->do_checkin( $self, $inst_id, $trans_date, $return_date, $current_loc, $item_props );
 432
 433     if ($xact->ok) {
 434         $xact->patron($self->find_patron(usr => $xact->{circ_user_id}, slim_user => 1)) if $xact->{circ_user_id};
 435         delete $item->{patron};
 436         delete $item->{due_date};
 437         syslog('LOG_INFO', "OILS: Checkin succeeded");
 438     } else {
 439         syslog('LOG_WARNING', "OILS: Checkin failed");
 440     }
 441
 442     syslog('LOG_INFO', "OILS: SIP Checkin request took %0.3f seconds", (time() - $start_time));
 443     return $xact;
 444 }
 445
 446 ## If the ILS caches patron information, this lets it free it up.
 447 ## Also, this could be used for centrally logging session duration.
 448 ## We don't do anything with it.
 449 sub end_patron_session {
 450     my ($self, $patron_id) = @_;
 451     return (1, 'Thank you!', '');
 452 }
 453
 454
 455 sub pay_fee {
 456     my ($self, $patron_id, $patron_pwd, $fee_amt, $fee_type,
 457     $pay_type, $fee_id, $trans_id, $currency) = @_;
 458
 459     $self->verify_session;
 460
 461     my $xact = OpenILS::SIP::Transaction::FeePayment->new(authtoken => $self->{authtoken});
 462     my $patron = $self->find_patron($patron_id);
 463
 464     if (!$patron) {
 465         $xact->screen_msg("Invalid Patron Barcode '$patron_id'");
 466         $xact->ok(0);
 467         return $xact;
 468     }
 469
 470     $xact->patron($patron);
 471     $xact->sip_currency($currency);
 472     $xact->fee_amount($fee_amt);
 473     $xact->sip_fee_type($fee_type);
 474     $xact->transaction_id($trans_id);
 475     $xact->fee_id($fee_id);
 476     $xact->sip_payment_type($pay_type);
 477     # We don't presently use this, but we might in the future.
 478     $xact->patron_password($patron_pwd);
 479
 480     $xact->do_fee_payment();
 481
 482     return $xact;
 483 }
 484
 485 #sub add_hold {
 486 #    my ($self, $patron_id, $patron_pwd, $item_id, $title_id,
 487 #    $expiry_date, $pickup_location, $hold_type, $fee_ack) = @_;
 488 #    my ($patron, $item);
 489 #    my $hold;
 490 #    my $trans;
 491 #
 492 #
 493 #    $trans = new ILS::Transaction::Hold;
 494 #
 495 #    # BEGIN TRANSACTION
 496 #    $patron = new ILS::Patron $patron_id;
 497 #    if (!$patron
 498 #    || (defined($patron_pwd) && !$patron->check_password($patron_pwd))) {
 499 #    $trans->screen_msg("Invalid Patron.");
 500 #
 501 #    return $trans;
 502 #    }
 503 #
 504 #    $item = new ILS::Item ($item_id || $title_id);
 505 #    if (!$item) {
 506 #    $trans->screen_msg("No such item.");
 507 #
 508 #    # END TRANSACTION (conditionally)
 509 #    return $trans;
 510 #    } elsif ($item->fee && ($fee_ack ne 'Y')) {
 511 #    $trans->screen_msg = "Fee required to place hold.";
 512 #
 513 #    # END TRANSACTION (conditionally)
 514 #    return $trans;
 515 #    }
 516 #
 517 #    $hold = {
 518 #    item_id         => $item->id,
 519 #    patron_id       => $patron->id,
 520 #    expiration_date => $expiry_date,
 521 #    pickup_location => $pickup_location,
 522 #    hold_type       => $hold_type,
 523 #    };
 524 #
 525 #    $trans->ok(1);
 526 #    $trans->patron($patron);
 527 #    $trans->item($item);
 528 #    $trans->pickup_location($pickup_location);
 529 #
 530 #    push(@{$item->hold_queue}, $hold);
 531 #    push(@{$patron->{hold_items}}, $hold);
 532 #
 533 #
 534 #    # END TRANSACTION
 535 #    return $trans;
 536 #}
 537 #
 538 #sub cancel_hold {
 539 #    my ($self, $patron_id, $patron_pwd, $item_id, $title_id) = @_;
 540 #    my ($patron, $item, $hold);
 541 #    my $trans;
 542 #
 543 #    $trans = new ILS::Transaction::Hold;
 544 #
 545 #    # BEGIN TRANSACTION
 546 #    $patron = new ILS::Patron $patron_id;
 547 #    if (!$patron) {
 548 #    $trans->screen_msg("Invalid patron barcode.");
 549 #
 550 #    return $trans;
 551 #    } elsif (defined($patron_pwd) && !$patron->check_password($patron_pwd)) {
 552 #    $trans->screen_msg('Invalid patron password.');
 553 #
 554 #    return $trans;
 555 #    }
 556 #
 557 #    $item = new ILS::Item ($item_id || $title_id);
 558 #    if (!$item) {
 559 #    $trans->screen_msg("No such item.");
 560 #
 561 #    # END TRANSACTION (conditionally)
 562 #    return $trans;
 563 #    }
 564 #
 565 #    # Remove the hold from the patron's record first
 566 #    $trans->ok($patron->drop_hold($item_id));
 567 #
 568 #    if (!$trans->ok) {
 569 #    # We didn't find it on the patron record
 570 #    $trans->screen_msg("No such hold on patron record.");
 571 #
 572 #    # END TRANSACTION (conditionally)
 573 #    return $trans;
 574 #    }
 575 #
 576 #    # Now, remove it from the item record.  If it was on the patron
 577 #    # record but not on the item record, we'll treat that as success.
 578 #    foreach my $i (0 .. scalar @{$item->hold_queue}) {
 579 #    $hold = $item->hold_queue->[$i];
 580 #
 581 #    if ($hold->{patron_id} eq $patron->id) {
 582 #        # found it: delete it.
 583 #        splice @{$item->hold_queue}, $i, 1;
 584 #        last;
 585 #    }
 586 #    }
 587 #
 588 #    $trans->screen_msg("Hold Cancelled.");
 589 #    $trans->patron($patron);
 590 #    $trans->item($item);
 591 #
 592 #    return $trans;
 593 #}
 594 #
 595 #
 596 ## The patron and item id's can't be altered, but the
 597 ## date, location, and type can.
 598 #sub alter_hold {
 599 #    my ($self, $patron_id, $patron_pwd, $item_id, $title_id,
 600 #    $expiry_date, $pickup_location, $hold_type, $fee_ack) = @_;
 601 #    my ($patron, $item);
 602 #    my $hold;
 603 #    my $trans;
 604 #
 605 #    $trans = new ILS::Transaction::Hold;
 606 #
 607 #    # BEGIN TRANSACTION
 608 #    $patron = new ILS::Patron $patron_id;
 609 #    if (!$patron) {
 610 #    $trans->screen_msg("Invalid patron barcode.");
 611 #
 612 #    return $trans;
 613 #    }
 614 #
 615 #    foreach my $i (0 .. scalar @{$patron->{hold_items}}) {
 616 #    $hold = $patron->{hold_items}[$i];
 617 #
 618 #    if ($hold->{item_id} eq $item_id) {
 619 #        # Found it.  So fix it.
 620 #        $hold->{expiration_date} = $expiry_date if $expiry_date;
 621 #        $hold->{pickup_location} = $pickup_location if $pickup_location;
 622 #        $hold->{hold_type} = $hold_type if $hold_type;
 623 #
 624 #        $trans->ok(1);
 625 #        $trans->screen_msg("Hold updated.");
 626 #        $trans->patron($patron);
 627 #        $trans->item(new ILS::Item $hold->{item_id});
 628 #        last;
 629 #    }
 630 #    }
 631 #
 632 #    # The same hold structure is linked into both the patron's
 633 #    # list of hold items and into the queue of outstanding holds
 634 #    # for the item, so we don't need to search the hold queue for
 635 #    # the item, since it's already been updated by the patron code.
 636 #
 637 #    if (!$trans->ok) {
 638 #    $trans->screen_msg("No such outstanding hold.");
 639 #    }
 640 #
 641 #    return $trans;
 642 #}
 643
 644
 645 sub renew {
 646     my ($self, $patron_id, $patron_pwd, $item_id, $title_id,
 647         $no_block, $nb_due_date, $third_party, $item_props, $fee_ack) = @_;
 648
 649     $self->verify_session;
 650
 651     my $trans = OpenILS::SIP::Transaction::Renew->new( authtoken => $self->{authtoken} );
 652     $trans->patron($self->find_patron($patron_id));
 653     $trans->item($self->find_item($item_id));
 654
 655     if(!$trans->patron) {
 656         $trans->screen_msg("Invalid patron barcode.");
 657         $trans->ok(0);
 658         return $trans;
 659     }
 660
 661     if(!$trans->patron->renew_ok) {
 662         $trans->screen_msg("Renewals not allowed.");
 663         $trans->ok(0);
 664         return $trans;
 665     }
 666
 667     if(!$trans->item) {
 668         if( $title_id ) {
 669             $trans->screen_msg("Title ID renewal not supported.  Use item barcode.");
 670         } else {
 671             $trans->screen_msg("Invalid item barcode.");
 672         }
 673         $trans->ok(0);
 674         return $trans;
 675     }
 676
 677     if(!$trans->item->{patron} or
 678             $trans->item->{patron} ne $patron_id) {
 679         $trans->screen_msg("Item not checked out to " . $trans->patron->name);
 680         $trans->ok(0);
 681         return $trans;
 682     }
 683
 684     # Perform the renewal
 685     $trans->do_renew();
 686
 687     $trans->desensitize(0);    # It's already checked out
 688     $trans->item->{due_date} = $nb_due_date if $no_block eq 'Y';
 689     $trans->item->{sip_item_properties} = $item_props if $item_props;
 690
 691     return $trans;
 692 }
 693
 694
 695
 696
 697
 698 #
 699 #sub renew_all {
 700 #    my ($self, $patron_id, $patron_pwd, $fee_ack) = @_;
 701 #    my ($patron, $item_id);
 702 #    my $trans;
 703 #
 704 #    $trans = new ILS::Transaction::RenewAll;
 705 #
 706 #    $trans->patron($patron = new ILS::Patron $patron_id);
 707 #    if (defined $patron) {
 708 #    syslog("LOG_DEBUG", "ILS::renew_all: patron '%s': renew_ok: %s",
 709 #           $patron->name, $patron->renew_ok);
 710 #    } else {
 711 #    syslog("LOG_DEBUG", "ILS::renew_all: Invalid patron id: '%s'",
 712 #           $patron_id);
 713 #    }
 714 #
 715 #    if (!defined($patron)) {
 716 #    $trans->screen_msg("Invalid patron barcode.");
 717 #    return $trans;
 718 #    } elsif (!$patron->renew_ok) {
 719 #    $trans->screen_msg("Renewals not allowed.");
 720 #    return $trans;
 721 #    } elsif (defined($patron_pwd) && !$patron->check_password($patron_pwd)) {
 722 #    $trans->screen_msg("Invalid patron password.");
 723 #    return $trans;
 724 #    }
 725 #
 726 #    foreach $item_id (@{$patron->{items}}) {
 727 #    my $item = new ILS::Item $item_id;
 728 #
 729 #    if (!defined($item)) {
 730 #        syslog("LOG_WARNING",
 731 #           "renew_all: Invalid item id associated with patron '%s'",
 732 #           $patron->id);
 733 #        next;
 734 #    }
 735 #
 736 #    if (@{$item->hold_queue}) {
 737 #        # Can't renew if there are outstanding holds
 738 #        push @{$trans->unrenewed}, $item_id;
 739 #    } else {
 740 #        $item->{due_date} = time + (14*24*60*60); # two weeks hence
 741 #        push @{$trans->renewed}, $item_id;
 742 #    }
 743 #    }
 744 #
 745 #    $trans->ok(1);
 746 #
 747 #    return $trans;
 748 #}
 749
 750 1;