lib/NCIP/ILS/Evergreen.pm

   1 # ---------------------------------------------------------------
   2 # Copyright © 2014 Jason J.A. Stephenson <jason@sigio.com>
   3 #
   4 # This file is part of NCIPServer.
   5 #
   6 # NCIPServer is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # NCIPServer is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with NCIPServer.  If not, see <http://www.gnu.org/licenses/>.
  18 # ---------------------------------------------------------------
  19 package NCIP::ILS::Evergreen;
  20
  21 use Modern::Perl;
  22 use XML::LibXML::Simple qw(XMLin);
  23 use DateTime;
  24 use DateTime::Format::ISO8601;
  25 use Digest::MD5 qw/md5_hex/;
  26 use OpenSRF::System;
  27 use OpenSRF::AppSession;
  28 use OpenSRF::Utils qw/:datetime/;
  29 use OpenSRF::Utils::SettingsClient;
  30 use OpenILS::Utils::Fieldmapper;
  31 use OpenILS::Utils::Normalize qw(clean_marc);
  32 use OpenILS::Application::AppUtils;
  33 use OpenILS::Const qw/:const/;
  34 use MARC::Record;
  35 use MARC::Field;
  36 use MARC::File::XML;
  37 use List::MoreUtils qw/uniq/;
  38 use POSIX qw/strftime/;
  39
  40 # We need a bunch of NCIP::* objects.
  41 use NCIP::Response;
  42 use NCIP::Problem;
  43 use NCIP::User;
  44 use NCIP::User::OptionalFields;
  45 use NCIP::User::AddressInformation;
  46 use NCIP::User::Id;
  47 use NCIP::User::BlockOrTrap;
  48 use NCIP::User::Privilege;
  49 use NCIP::User::PrivilegeStatus;
  50 use NCIP::StructuredPersonalUserName;
  51 use NCIP::StructuredAddress;
  52 use NCIP::ElectronicAddress;
  53 use NCIP::RequestId;
  54 use NCIP::Item::Id;
  55
  56 # Inherit from NCIP::ILS.
  57 use parent qw(NCIP::ILS);
  58
  59 =head1 NAME
  60
  61 Evergreen - Evergreen driver for NCIPServer
  62
  63 =head1 SYNOPSIS
  64
  65     my $ils = NCIP::ILS::Evergreen->new(name => $config->{NCIP.ils.value});
  66
  67 =head1 DESCRIPTION
  68
  69 NCIP::ILS::Evergreen is the default driver for Evergreen and
  70 NCIPServer. It was initially developed to work with Auto-Graphics'
  71 SHAREit software using a subset of an unspecified ILL/DCB profile.
  72
  73 =cut
  74
  75 # Default values we define for things that might be missing in our
  76 # runtime environment or configuration file that absolutely must have
  77 # values.
  78 #
  79 # OILS_NCIP_CONFIG_DEFAULT is the default location to find our
  80 # driver's configuration file.  This location can be overridden by
  81 # setting the path in the OILS_NCIP_CONFIG environment variable.
  82 #
  83 # BIB_SOURCE_DEFAULT is the config.bib_source.id to use when creating
  84 # "short" bibs.  It is used only if no entry is supplied in the
  85 # configuration file.  The provided default is 2, the id of the
  86 # "System Local" source that comes with a default Evergreen
  87 # installation.
  88 use constant {
  89     OILS_NCIP_CONFIG_DEFAULT => '/openils/conf/oils_ncip.xml',
  90     BIB_SOURCE_DEFAULT => 2
  91 };
  92
  93 # A common Evergreen code shortcut to use AppUtils:
  94 my $U = 'OpenILS::Application::AppUtils';
  95
  96 # The usual constructor:
  97 sub new {
  98     my $class = shift;
  99     $class = ref($class) if (ref $class);
 100
 101     # Instantiate our parent with the rest of the arguments.  It
 102     # creates a blessed hashref.
 103     my $self = $class->SUPER::new(@_);
 104
 105     # Look for our configuration file, load, and parse it:
 106     $self->_configure();
 107
 108     # Bootstrap OpenSRF and prepare some OpenILS components.
 109     $self->_bootstrap();
 110
 111     # Initialize the rest of our internal state.
 112     $self->_init();
 113
 114     return $self;
 115 }
 116
 117 =head1 HANDLER METHODS
 118
 119 =head2 lookupuser
 120
 121     $ils->lookupuser($request);
 122
 123 Processes a LookupUser request.
 124
 125 =cut
 126
 127 sub lookupuser {
 128     my $self = shift;
 129     my $request = shift;
 130
 131     # Check our session and login if necessary.
 132     $self->login() unless ($self->checkauth());
 133
 134     my $message_type = $self->parse_request_type($request);
 135
 136     # Let's go ahead and create our response object. We need this even
 137     # if there is a problem.
 138     my $response = NCIP::Response->new({type => $message_type . "Response"});
 139     $response->header($self->make_header($request));
 140
 141     # Need to parse the request object to get the user barcode.
 142     my ($barcode, $idfield) = $self->find_user_barcode($request);
 143
 144     # If we did not find a barcode, then report the problem.
 145     if (ref($barcode) eq 'NCIP::Problem') {
 146         $response->problem($barcode);
 147         return $response;
 148     }
 149
 150     # Look up our patron by barcode:
 151     my $user = $self->retrieve_user_by_barcode($barcode, $idfield);
 152     if (ref($user) eq 'NCIP::Problem') {
 153         $response->problem($user);
 154         return $response;
 155     }
 156
 157     # We got the information, so lets fill in our userdata.
 158     my $userdata = NCIP::User->new();
 159
 160     # Make an array of the user's active barcodes.
 161     my $ids = [];
 162     foreach my $card (@{$user->cards()}) {
 163         if ($U->is_true($card->active())) {
 164             my $id = NCIP::User::Id->new({
 165                 UserIdentifierType => 'Barcode',
 166                 UserIdentifierValue => $card->barcode()
 167             });
 168             push(@$ids, $id);
 169         }
 170     }
 171     $userdata->UserId($ids);
 172
 173     # Check if they requested any optional fields and return those.
 174     my $elements = $request->{$message_type}->{UserElementType};
 175     if ($elements) {
 176         $elements = [$elements] unless (ref $elements eq 'ARRAY');
 177         my $optionalfields = NCIP::User::OptionalFields->new();
 178
 179         # First, we'll look for name information.
 180         if (grep {$_ eq 'Name Information'} @$elements) {
 181             my $name = NCIP::StructuredPersonalUserName->new();
 182             $name->Surname($user->family_name());
 183             $name->GivenName($user->first_given_name());
 184             $name->Prefix($user->prefix());
 185             $name->Suffix($user->suffix());
 186             $optionalfields->NameInformation($name);
 187         }
 188
 189         # Next, check for user address information.
 190         if (grep {$_ eq 'User Address Information'} @$elements) {
 191             my $addresses = [];
 192
 193             # See if the user has any valid, physcial addresses.
 194             foreach my $addr (@{$user->addresses()}) {
 195                 next if ($U->is_true($addr->pending()));
 196                 my $address = NCIP::User::AddressInformation->new({UserAddressRoleType=>$addr->address_type()});
 197                 my $physical = NCIP::StructuredAddress->new();
 198                 $physical->Line1($addr->street1());
 199                 $physical->Line2($addr->street2());
 200                 $physical->Locality($addr->city());
 201                 $physical->Region($addr->state());
 202                 $physical->PostalCode($addr->post_code());
 203                 $physical->Country($addr->country());
 204                 $address->PhysicalAddress($physical);
 205                 push @$addresses, $address;
 206             }
 207
 208             # Right now, we're only sharing email address if the user
 209             # has it. We don't share phone numbers.
 210             if ($user->email()) {
 211                 my $address = NCIP::User::AddressInformation->new({UserAddressRoleType=>'Email Address'});
 212                 $address->ElectronicAddress(
 213                     NCIP::ElectronicAddress->new({
 214                         Type=>'Email Address',
 215                         Data=>$user->email()
 216                     })
 217                 );
 218                 push @$addresses, $address;
 219             }
 220
 221             $optionalfields->UserAddressInformation($addresses);
 222         }
 223
 224         # Check for User Privilege.
 225         if (grep {$_ eq 'User Privilege'} @$elements) {
 226             # Get the user's group:
 227             my $pgt = $U->simplereq(
 228                 'open-ils.pcrud',
 229                 'open-ils.pcrud.retrieve.pgt',
 230                 $self->{session}->{authtoken},
 231                 $user->profile()
 232             );
 233             if ($pgt) {
 234                 my $privilege = NCIP::User::Privilege->new();
 235                 $privilege->AgencyId($user->home_ou->shortname());
 236                 $privilege->AgencyUserPrivilegeType($pgt->name());
 237                 $privilege->ValidToDate($user->expire_date());
 238                 $privilege->ValidFromDate($user->create_date());
 239
 240                 my $status = 'Active';
 241                 if (_expired($user)) {
 242                     $status = 'Expired';
 243                 } elsif ($U->is_true($user->barred())) {
 244                     $status = 'Barred';
 245                 } elsif (!$U->is_true($user->active())) {
 246                     $status = 'Inactive';
 247                 }
 248                 if ($status) {
 249                     $privilege->UserPrivilegeStatus(
 250                         NCIP::User::PrivilegeStatus->new({
 251                             UserPrivilegeStatusType => $status
 252                         })
 253                     );
 254                 }
 255
 256                 $optionalfields->UserPrivilege([$privilege]);
 257             }
 258         }
 259
 260         # Check for Block Or Trap.
 261         if (grep {$_ eq 'Block Or Trap'} @$elements) {
 262             my $blocks = [];
 263
 264             # First, let's check if the profile is blocked from ILL.
 265             if (grep {$_->id() == $user->profile()} @{$self->{blocked_profiles}}) {
 266                 my $block = NCIP::User::BlockOrTrap->new();
 267                 $block->AgencyId($user->home_ou->shortname());
 268                 $block->BlockOrTrapType('Block Interlibrary Loan');
 269                 push @$blocks, $block;
 270             }
 271
 272             # Next, we loop through the user's standing penalties
 273             # looking for blocks on CIRC, HOLD, and RENEW.
 274             my ($have_circ, $have_renew, $have_hold) = (0,0,0);
 275             foreach my $penalty (@{$user->standing_penalties()}) {
 276                 next unless($penalty->standing_penalty->block_list());
 277                 my @block_list = split(/\|/, $penalty->standing_penalty->block_list());
 278                 my $ou = $U->simplereq(
 279                     'open-ils.pcrud',
 280                     'open-ils.pcrud.retrieve.aou',
 281                     $self->{session}->{authtoken},
 282                     $penalty->org_unit()
 283                 );
 284
 285                 # Block checkout.
 286                 if (!$have_circ && grep {$_ eq 'CIRC'} @block_list) {
 287                     my $bot = NCIP::User::BlockOrTrap->new();
 288                     $bot->AgencyId($ou->shortname());
 289                     $bot->BlockOrTrapType('Block Checkout');
 290                     push @$blocks, $bot;
 291                     $have_circ = 1;
 292                 }
 293
 294                 # Block holds.
 295                 if (!$have_hold && grep {$_ eq 'HOLD' || $_ eq 'FULFILL'} @block_list) {
 296                     my $bot = NCIP::User::BlockOrTrap->new();
 297                     $bot->AgencyId($ou->shortname());
 298                     $bot->BlockOrTrapType('Block Holds');
 299                     push @$blocks, $bot;
 300                     $have_hold = 1;
 301                 }
 302
 303                 # Block renewals.
 304                 if (!$have_renew && grep {$_ eq 'RENEW'} @block_list) {
 305                     my $bot = NCIP::User::BlockOrTrap->new();
 306                     $bot->AgencyId($ou->shortname());
 307                     $bot->BlockOrTrapType('Block Renewals');
 308                     push @$blocks, $bot;
 309                     $have_renew = 1;
 310                 }
 311
 312                 # Stop after we report one of each, even if more
 313                 # blocks remain.
 314                 last if ($have_circ && $have_renew && $have_hold);
 315             }
 316
 317             $optionalfields->BlockOrTrap($blocks);
 318         }
 319
 320         $userdata->UserOptionalFields($optionalfields);
 321     }
 322
 323     $response->data($userdata);
 324
 325     return $response;
 326 }
 327
 328 =head2 acceptitem
 329
 330     $ils->acceptitem($request);
 331
 332 Processes an AcceptItem request.
 333
 334 =cut
 335
 336 sub acceptitem {
 337     my $self = shift;
 338     my $request = shift;
 339
 340     # Check our session and login if necessary.
 341     $self->login() unless ($self->checkauth());
 342
 343     # Common preparation.
 344     my $message = $self->parse_request_type($request);
 345     my $response = NCIP::Response->new({type => $message . 'Response'});
 346     $response->header($self->make_header($request));
 347
 348     # We only accept holds for the time being.
 349     if ($request->{$message}->{RequestedActionType} !~ /^hold\w/i) {
 350         # We need the item id or we can't do anything at all.
 351         my ($item_barcode, $item_idfield) = $self->find_item_barcode($request);
 352         if (ref($item_barcode) eq 'NCIP::Problem') {
 353             $response->problem($item_barcode);
 354             return $response;
 355         }
 356
 357         # We need to find a patron barcode or we can't look anyone up
 358         # to place a hold.
 359         my ($user_barcode, $user_idfield) = $self->find_user_barcode($request, 'UserIdentifierValue');
 360         if (ref($user_barcode) eq 'NCIP::Problem') {
 361             $response->problem($user_barcode);
 362             return $response;
 363         }
 364         # Look up our patron by barcode:
 365         my $user = $self->retrieve_user_by_barcode($user_barcode, $user_idfield);
 366         if (ref($user) eq 'NCIP::Problem') {
 367             $response->problem($user);
 368             return $response;
 369         }
 370         # We're doing patron checks before looking for bibliographic
 371         # information and creating the item because problems with the
 372         # patron are more likely to occur.
 373         my $problem = $self->check_user_for_problems($user, 'HOLD');
 374         if ($problem) {
 375             $response->problem($problem);
 376             return $response;
 377         }
 378
 379         # Check if the item barcode already exists:
 380         my $item = $self->retrieve_copy_details_by_barcode($item_barcode);
 381         if ($item) {
 382             # What to do here was not defined in the
 383             # specification. Since the copies that we create this way
 384             # should get deleted when checked in, it would be an error
 385             # if we try to create another one. It means that something
 386             # has gone wrong somewhere.
 387             $response->problem(
 388                 NCIP::Problem->new(
 389                     {
 390                         ProblemType => 'Duplicate Item',
 391                         ProblemDetail => "Item with barcode $item_barcode already exists.",
 392                         ProblemElement => $item_idfield,
 393                         ProblemValue => $item_barcode
 394                     }
 395                 )
 396             );
 397             return $response;
 398         }
 399
 400         # Now, we have to create our new copy and/or bib and call number.
 401
 402         # First, we have to gather the necessary information from the
 403         # request.  Store in a hashref for convenience. We may write a
 404         # method to get this information in the future if we find we
 405         # need it in other handlers. Such a function would be a
 406         # candidate to go into our parent, NCIP::ILS.
 407         my $item_info = {
 408             barcode => $item_barcode,
 409             call_number => $request->{$message}->{ItemOptionalFields}->{ItemDescription}->{CallNumber},
 410             title => $request->{$message}->{ItemOptionalFields}->{BibliographicDescription}->{Author},
 411             author => $request->{$message}->{ItemOptionalFields}->{BibliographicDescription}->{Title},
 412             publisher => $request->{$message}->{ItemOptionalFields}->{BibliographicDescription}->{Publisher},
 413             publication_date => $request->{$message}->{ItemOptionalFields}->{BibliographicDescription}->{PublicationDate},
 414             medium => $request->{$message}->{ItemOptionalFields}->{BibliographicDescription}->{MediumType},
 415             electronic => $request->{$message}->{ItemOptionalFields}->{BibliographicDescription}->{ElectronicResource}
 416         };
 417
 418         if ($self->{config}->{items}->{use_precats}) {
 419             # We only need to create a precat copy.
 420             $item = $self->create_precat_copy($item_info);
 421         } else {
 422             # We have to create a "partial" bib record, a call number and a copy.
 423             $item = $self->create_fuller_copy($item_info);
 424         }
 425
 426         # If we failed to create the copy, report a problem.
 427         unless ($item) {
 428             $response->problem(
 429                 {
 430                     ProblemType => 'Temporary Processing Failure',
 431                     ProblemDetail => 'Failed to create the item in the system',
 432                     ProblemElement => $item_idfield,
 433                     ProblemValue => $item_barcode
 434                 }
 435             );
 436             return $response;
 437         }
 438
 439         # We try to find the pickup location in our database. It's OK
 440         # if it does not exist, the user's home library will be used
 441         # instead.
 442         my $location = $request->{$message}->{PickupLocation};
 443         if ($location) {
 444             $location = $self->retrieve_org_unit_by_shortname($location);
 445         }
 446
 447         # Now, we place the hold on the newly created copy on behalf
 448         # of the patron retrieved above.
 449         my $hold = $self->place_hold($item, $user, $location);
 450         if (ref($hold) eq 'NCIP::Problem') {
 451             $response->problem($hold);
 452             return $response;
 453         }
 454
 455         # We return the RequestId and optionally, the ItemID. We'll
 456         # just return what was sent to us, since we ignored all of it
 457         # but the barcode.
 458         my $data = {};
 459         $data->{RequestId} = NCIP::RequestId->new(
 460             {
 461                 AgencyId => $request->{$message}->{RequestId}->{AgencyId},
 462                 RequestIdentifierType => $request->{$message}->{RequestId}->{RequestIdentifierType},
 463                 RequestIdentifierValue => $request->{$message}->{RequestId}->{RequestIdentifierValue}
 464             }
 465         );
 466         $data->{ItemId} = NCIP::Item::Id->new(
 467             {
 468                 AgencyId => $request->{$message}->{ItemId}->{AgencyId},
 469                 ItemIdentifierType => $request->{$message}->{ItemId}->{ItemIdentifierType},
 470                 ItemIdentifierValue => $request->{$message}->{ItemId}->{ItemIdentifierValue}
 471             }
 472         );
 473         $response->data($data);
 474
 475     } else {
 476         my $problem = NCIP::Problem->new();
 477         $problem->ProblemType('Unauthorized Combination Of Element Values For System');
 478         $problem->ProblemDetail('We only support Hold For Pickup');
 479         $problem->ProblemElement('RequestedActionType');
 480         $problem->ProblemValue($request->{$message}->{RequestedActionType});
 481         $response->problem($problem);
 482     }
 483
 484     return $response;
 485 }
 486
 487 =head2 checkinitem
 488
 489     $response = $ils->checkinitem($request);
 490
 491 Checks the item in if we can find the barcode in the message. It
 492 returns problems if it cannot find the item in the system or if the
 493 item is not checked out.
 494
 495 It could definitely use some more brains at some point as it does not
 496 fully support everything that the standard allows. It also does not
 497 really check if the checkin succeeded or not.
 498
 499 =cut
 500
 501 sub checkinitem {
 502     my $self = shift;
 503     my $request = shift;
 504
 505     # Check our session and login if necessary:
 506     $self->login() unless ($self->checkauth());
 507
 508     # Common stuff:
 509     my $message = $self->parse_request_type($request);
 510     my $response = NCIP::Response->new({type => $message . 'Response'});
 511     $response->header($self->make_header($request));
 512
 513     # We need the copy barcode from the message.
 514     my ($item_barcode, $item_idfield) = $self->find_item_barcode($request);
 515     if (ref($item_barcode) eq 'NCIP::Problem') {
 516         $response->problem($item_barcode);
 517         return $response;
 518     }
 519
 520     # Retrieve the copy details.
 521     my $details = $self->retrieve_copy_details_by_barcode($item_barcode);
 522     unless ($details) {
 523         # Return an Unkown Item problem unless we find the copy.
 524         $response->problem(
 525             NCIP::Problem->new(
 526                 {
 527                     ProblemType => 'Unknown Item',
 528                     ProblemDetail => "Item with barcode $item_barcode is not known.",
 529                     ProblemElement => $item_idfield,
 530                     ProblemValue => $item_barcode
 531                 }
 532             )
 533         );
 534         return $response;
 535     }
 536
 537     # Check if a UserId was provided. If so, this is the patron to
 538     # whom the copy should be checked out.
 539     my $user;
 540     my ($user_barcode, $user_idfield) = $self->find_user_barcode($request);
 541     # We ignore the problem, because the UserId is optional.
 542     if (ref($user_barcode) ne 'NCIP::Problem') {
 543         $user = $self->retrieve_user_by_barcode($user_barcode, $user_idfield);
 544         # We don't ignore a problem here, however.
 545         if (ref($user) eq 'NCIP::Problem') {
 546             $response->problem($user);
 547             return $response;
 548         }
 549     }
 550
 551     # Isolate the copy.
 552     my $copy = $details->{copy};
 553
 554     # Look for a circulation and examine its information:
 555     my $circ = $details->{circ};
 556
 557     # Check the circ details to see if the copy is checked out and, if
 558     # the patron was provided, that it is checked out to the patron in
 559     # question. We also verify the copy ownership and circulation
 560     # location.
 561     my $problem = $self->check_circ_details($circ, $copy, $user);
 562     if ($problem) {
 563         # We need to fill in some information, however.
 564         if (!$problem->ProblemValue() && !$problem->ProblemElement()) {
 565             $problem->ProblemValue($user_barcode);
 566             $problem->ProblemElement($user_idfield);
 567         } elsif (!$problem->ProblemElement()) {
 568             $problem->ProblemElement($item_idfield);
 569         }
 570         $response->problem($problem);
 571         return $response;
 572     }
 573
 574     # Checkin parameters. We want to skip hold targeting or making
 575     # transits, to force the checkin despite the copy status, as
 576     # well as void overdues.
 577     my $params = {
 578         copy_barcode => $copy->barcode(),
 579         force => 1,
 580         noop => 1,
 581         void_overdues => 1
 582     };
 583     my $result = $U->simplereq(
 584         'open-ils.circ',
 585         'open-ils.circ.checkin.override',
 586         $self->{session}->{authtoken},
 587         $params
 588     );
 589     if (ref($result) eq 'ARRAY') {
 590         $result = $result->[0];
 591     }
 592     if ($result->{textcode} eq 'SUCCESS') {
 593         # Delete the copy. Since delete_copy checks ownership
 594         # before attempting to delete the copy, we don't bother
 595         # checking who owns it.
 596         $self->delete_copy($copy);
 597         # We need the circulation user for the information below, so we retrieve it.
 598         my $circ_user = $self->retrieve_user_by_id($circ->usr());
 599         my $data = {
 600             ItemId => NCIP::Item::Id->new(
 601                 {
 602                     AgencyId => $request->{$message}->{ItemId}->{AgencyId},
 603                     ItemIdentifierType => $request->{$message}->{ItemId}->{ItemIdentifierType},
 604                     ItemIdentifierValue => $request->{$message}->{ItemId}->{ItemIdentifierValue}
 605                 }
 606             ),
 607             UserId => NCIP::User::Id->new(
 608                 {
 609                     UserIdentifierType => 'Barcode Id',
 610                     UserIdentifierValue => $circ_user->card->barcode()
 611                 }
 612             )
 613         };
 614
 615         $response->data($data);
 616
 617         # At some point in the future, we should probably check if
 618         # they requested optional user or item elements and return
 619         # those. For the time being, we ignore those at the risk of
 620         # being considered non-compliant.
 621     } else {
 622         $response->problem(_problem_from_event('Checkin Failed', $result));
 623     }
 624
 625     return $response
 626 }
 627
 628 =head2 renewitem
 629
 630     $response = $ils->renewitem($request);
 631
 632 Handle the RenewItem message.
 633
 634 =cut
 635
 636 sub renewitem {
 637     my $self = shift;
 638     my $request = shift;
 639
 640     # Check our session and login if necessary:
 641     $self->login() unless ($self->checkauth());
 642
 643     # Common stuff:
 644     my $message = $self->parse_request_type($request);
 645     my $response = NCIP::Response->new({type => $message . 'Response'});
 646     $response->header($self->make_header($request));
 647
 648     # We need the copy barcode from the message.
 649     my ($item_barcode, $item_idfield) = $self->find_item_barcode($request);
 650     if (ref($item_barcode) eq 'NCIP::Problem') {
 651         $response->problem($item_barcode);
 652         return $response;
 653     }
 654
 655     # Retrieve the copy details.
 656     my $details = $self->retrieve_copy_details_by_barcode($item_barcode);
 657     unless ($details) {
 658         # Return an Unkown Item problem unless we find the copy.
 659         $response->problem(
 660             NCIP::Problem->new(
 661                 {
 662                     ProblemType => 'Unknown Item',
 663                     ProblemDetail => "Item with barcode $item_barcode is not known.",
 664                     ProblemElement => $item_idfield,
 665                     ProblemValue => $item_barcode
 666                 }
 667             )
 668         );
 669         return $response;
 670     }
 671
 672     # User is required for RenewItem.
 673     my ($user_barcode, $user_idfield) = $self->find_user_barcode($request);
 674     if (ref($user_barcode) eq 'NCIP::Problem') {
 675         $response->problem($user_barcode);
 676         return $response;
 677     }
 678     my $user = $self->retrieve_user_by_barcode($user_barcode, $user_idfield);
 679     if (ref($user) eq 'NCIP::Problem') {
 680         $response->problem($user);
 681         return $response;
 682     }
 683
 684     # Isolate the copy.
 685     my $copy = $details->{copy};
 686
 687     # Look for a circulation and examine its information:
 688     my $circ = $details->{circ};
 689
 690     # Check the circ details to see if the copy is checked out and, if
 691     # the patron was provided, that it is checked out to the patron in
 692     # question. We also verify the copy ownership and circulation
 693     # location.
 694     my $problem = $self->check_circ_details($circ, $copy, $user);
 695     if ($problem) {
 696         # We need to fill in some information, however.
 697         if (!$problem->ProblemValue() && !$problem->ProblemElement()) {
 698             $problem->ProblemValue($user_barcode);
 699             $problem->ProblemElement($user_idfield);
 700         } elsif (!$problem->ProblemElement()) {
 701             $problem->ProblemElement($item_idfield);
 702         }
 703         $response->problem($problem);
 704         return $response;
 705     }
 706
 707     # Check if user is blocked from renewals:
 708     $problem = $self->check_user_for_problems($user, 'RENEW');
 709     if ($problem) {
 710         # Replace the ProblemElement and ProblemValue fields.
 711         $problem->ProblemElement($user_idfield);
 712         $problem->ProblemValue($user_barcode);
 713         $response->problem($problem);
 714         return $response;
 715     }
 716
 717     # Check if the duration rule allows renewals. It should have been
 718     # fleshed during the copy details retrieve.
 719     my $rule = $circ->duration_rule();
 720     unless (ref($rule)) {
 721         $rule = $U->simplereq(
 722             'open-ils.pcrud',
 723             'open-ils.pcrud.retrieve.crcd',
 724             $self->{session}->{authtoken},
 725             $rule
 726         )->gather(1);
 727     }
 728     if ($rule->max_renewals() < 1) {
 729         $response->problem(
 730             NCIP::Problem->new(
 731                 {
 732                     ProblemType => 'Item Not Renewable',
 733                     ProblemDetail => 'Item may not be renewed.',
 734                     ProblemElement => $item_idfield,
 735                     ProblemValue => $item_barcode
 736                 }
 737             )
 738         );
 739         return $response;
 740     }
 741
 742     # Check if there are renewals remaining on the latest circ:
 743     if ($circ->renewal_remaining() < 1) {
 744         $response->problem(
 745             NCIP::Problem->new(
 746                 {
 747                     ProblemType => 'Maximum Renewals Exceeded',
 748                     ProblemDetail => 'Renewal cannot proceed because the User has already renewed the Item the maximum number of times permitted.',
 749                     ProblemElement => $item_idfield,
 750                     ProblemValue => $item_barcode
 751                 }
 752             )
 753         );
 754         return $response;
 755     }
 756
 757     # Now, we attempt the renewal. If it fails, we simply say that the
 758     # user is not allowed to renew this item, without getting into
 759     # details.
 760     my $params = {
 761         copy => $copy,
 762         patron_id => $user->id(),
 763         sip_renewal => 1
 764     };
 765     my $r = $U->simplereq(
 766         'open-ils.circ',
 767         'open-ils.circ.renew.override',
 768         $self->{session}->{authtoken},
 769         $params
 770     )->gather(1);
 771
 772     # We only look at the first one, since more than one usually means
 773     # failure.
 774     if (ref($r) eq 'ARRAY') {
 775         $r = $r->[0];
 776     }
 777     if ($r->{textcode} ne 'SUCCESS') {
 778         $problem = _problem_from_event('Renewal Failed', $r);
 779         $response->problem($problem);
 780     } else {
 781         my $data = {
 782             ItemId => NCIP::Item::Id->new(
 783                 {
 784                     AgencyId => $request->{$message}->{ItemId}->{AgencyId},
 785                     ItemIdentifierType => $request->{$message}->{ItemId}->{ItemIdentifierType},
 786                     ItemIdentifierValue => $request->{$message}->{ItemId}->{ItemIdentifierValue}
 787                 }
 788             ),
 789             UserId => NCIP::User::Id->new(
 790                 {
 791                     UserIdentifierType => 'Barcode Id',
 792                     UserIdentifierValue => $user->card->barcode()
 793                 }
 794             )
 795         };
 796         # We need to retrieve the copy details again to refresh our
 797         # circ information to get the new due date.
 798         $details = $self->retrieve_copy_details_by_barcode($item_barcode);
 799         $circ = $details->{circ};
 800         my $due = DateTime::Format::ISO8601->parse_datetime(cleanse_ISO8601($circ->due_date()));
 801         $due->set_time_zone('UTC');
 802         $data->{DateDue} = $due->iso8601();
 803
 804         $response->data($data);
 805     }
 806
 807     # At some point in the future, we should probably check if
 808     # they requested optional user or item elements and return
 809     # those. For the time being, we ignore those at the risk of
 810     # being considered non-compliant.
 811
 812     return $response;
 813 }
 814
 815 =head2 checkoutitem
 816
 817     $response = $ils->checkoutitem($request);
 818
 819 Handle the Checkoutitem message.
 820
 821 =cut
 822
 823 sub checkoutitem {
 824     my $self = shift;
 825     my $request = shift;
 826
 827     # Check our session and login if necessary:
 828     $self->login() unless ($self->checkauth());
 829
 830     # Common stuff:
 831     my $message = $self->parse_request_type($request);
 832     my $response = NCIP::Response->new({type => $message . 'Response'});
 833     $response->header($self->make_header($request));
 834
 835     # We need the copy barcode from the message.
 836     my ($item_barcode, $item_idfield) = $self->find_item_barcode($request);
 837     if (ref($item_barcode) eq 'NCIP::Problem') {
 838         $response->problem($item_barcode);
 839         return $response;
 840     }
 841
 842     # Retrieve the copy details.
 843     my $details = $self->retrieve_copy_details_by_barcode($item_barcode);
 844     unless ($details) {
 845         # Return an Unkown Item problem unless we find the copy.
 846         $response->problem(
 847             NCIP::Problem->new(
 848                 {
 849                     ProblemType => 'Unknown Item',
 850                     ProblemDetail => "Item with barcode $item_barcode is not known.",
 851                     ProblemElement => $item_idfield,
 852                     ProblemValue => $item_barcode
 853                 }
 854             )
 855         );
 856         return $response;
 857     }
 858
 859     # User is required for CheckOutItem.
 860     my ($user_barcode, $user_idfield) = $self->find_user_barcode($request);
 861     if (ref($user_barcode) eq 'NCIP::Problem') {
 862         $response->problem($user_barcode);
 863         return $response;
 864     }
 865     my $user = $self->retrieve_user_by_barcode($user_barcode, $user_idfield);
 866     if (ref($user) eq 'NCIP::Problem') {
 867         $response->problem($user);
 868         return $response;
 869     }
 870
 871     # Isolate the copy.
 872     my $copy = $details->{copy};
 873
 874     # Check if the copy can circulate.
 875     unless ($self->copy_can_circulate($copy)) {
 876         $response->problem(
 877             NCIP::Problem->new(
 878                 {
 879                     ProblemType => 'Item Does Not Circulate',
 880                     ProblemDetail => "Item with barcode $item_barcode does not circulate.",
 881                     ProblemElement => $item_idfield,
 882                     ProblemValue => $item_barcode
 883                 }
 884             )
 885         );
 886         return $response;
 887     }
 888
 889     # Look for a circulation and examine its information:
 890     my $circ = $details->{circ};
 891
 892     # Check if the item is already checked out.
 893     if ($circ && !$circ->checkin_time()) {
 894         $response->problem(
 895             NCIP::Problem->new(
 896                 {
 897                     ProblemType => 'Item Already Checked Out',
 898                     ProblemDetail => "Item with barcode $item_barcode is already checked out.",
 899                     ProblemElement => $item_idfield,
 900                     ProblemValue => $item_barcode
 901                 }
 902             )
 903         );
 904         return $response;
 905     }
 906
 907     # Check if user is blocked from circulation:
 908     my $problem = $self->check_user_for_problems($user, 'CIRC');
 909     if ($problem) {
 910         # Replace the ProblemElement and ProblemValue fields.
 911         $problem->ProblemElement($user_idfield);
 912         $problem->ProblemValue($user_barcode);
 913         $response->problem($problem);
 914         return $response;
 915     }
 916
 917     # Now, we attempt the check out. If it fails, we simply say that
 918     # the user is not allowed to check out this item, without getting
 919     # into details.
 920     my $params = {
 921         copy => $copy,
 922         patron_id => $user->id(),
 923     };
 924     my $r = $U->simplereq(
 925         'open-ils.circ',
 926         'open-ils.circ.checkout.full.override',
 927         $self->{session}->{authtoken},
 928         $params
 929     )->gather(1);
 930
 931     # We only look at the first one, since more than one usually means
 932     # failure.
 933     if (ref($r) eq 'ARRAY') {
 934         $r = $r->[0];
 935     }
 936     if ($r->{textcode} ne 'SUCCESS') {
 937         $problem = _problem_from_event('Check Out Failed', $r);
 938         $response->problem($problem);
 939     } else {
 940         my $data = {
 941             ItemId => NCIP::Item::Id->new(
 942                 {
 943                     AgencyId => $request->{$message}->{ItemId}->{AgencyId},
 944                     ItemIdentifierType => $request->{$message}->{ItemId}->{ItemIdentifierType},
 945                     ItemIdentifierValue => $request->{$message}->{ItemId}->{ItemIdentifierValue}
 946                 }
 947             ),
 948             UserId => NCIP::User::Id->new(
 949                 {
 950                     UserIdentifierType => 'Barcode Id',
 951                     UserIdentifierValue => $user->card->barcode()
 952                 }
 953             )
 954         };
 955         # We need to retrieve the copy details again to refresh our
 956         # circ information to get the due date.
 957         $details = $self->retrieve_copy_details_by_barcode($item_barcode);
 958         $circ = $details->{circ};
 959         my $due = DateTime::Format::ISO8601->parse_datetime(cleanse_ISO8601($circ->due_date()));
 960         $due->set_time_zone('UTC');
 961         $data->{DateDue} = $due->iso8601();
 962
 963         $response->data($data);
 964     }
 965
 966     # At some point in the future, we should probably check if
 967     # they requested optional user or item elements and return
 968     # those. For the time being, we ignore those at the risk of
 969     # being considered non-compliant.
 970
 971     return $response;
 972 }
 973
 974 =head1 METHODS USEFUL to SUBCLASSES
 975
 976 =head2 login
 977
 978     $ils->login();
 979
 980 Login to Evergreen via OpenSRF. It uses internal state from the
 981 configuration file to login.
 982
 983 =cut
 984
 985 # Login via OpenSRF to Evergreen.
 986 sub login {
 987     my $self = shift;
 988
 989     # Get the authentication seed.
 990     my $seed = $U->simplereq(
 991         'open-ils.auth',
 992         'open-ils.auth.authenticate.init',
 993         $self->{config}->{credentials}->{username}
 994     );
 995
 996     # Actually login.
 997     if ($seed) {
 998         my $response = $U->simplereq(
 999             'open-ils.auth',
1000             'open-ils.auth.authenticate.complete',
1001             {
1002                 username => $self->{config}->{credentials}->{username},
1003                 password => md5_hex(
1004                     $seed . md5_hex($self->{config}->{credentials}->{password})
1005                 ),
1006                 type => 'staff',
1007                 workstation => $self->{config}->{credentials}->{workstation}
1008             }
1009         );
1010         if ($response) {
1011             $self->{session}->{authtoken} = $response->{payload}->{authtoken};
1012             $self->{session}->{authtime} = $response->{payload}->{authtime};
1013
1014             # Set/reset the work_ou and user data in case something changed.
1015
1016             # Retrieve the work_ou as an object.
1017             $self->{session}->{work_ou} = $U->simplereq(
1018                 'open-ils.pcrud',
1019                 'open-ils.pcrud.search.aou',
1020                 $self->{session}->{authtoken},
1021                 {shortname => $self->{config}->{credentials}->{work_ou}}
1022             );
1023
1024             # We need the user information in order to do some things.
1025             $self->{session}->{user} = $U->check_user_session($self->{session}->{authtoken});
1026
1027         }
1028     }
1029 }
1030
1031 =head2 checkauth
1032
1033     $valid = $ils->checkauth();
1034
1035 Returns 1 if the object a 'valid' authtoken, 0 if not.
1036
1037 =cut
1038
1039 sub checkauth {
1040     my $self = shift;
1041
1042     # We use AppUtils to do the heavy lifting.
1043     if (defined($self->{session})) {
1044         if ($U->check_user_session($self->{session}->{authtoken})) {
1045             return 1;
1046         } else {
1047             return 0;
1048         }
1049     }
1050
1051     # If we reach here, we don't have a session, so we are definitely
1052     # not logged in.
1053     return 0;
1054 }
1055
1056 =head2 retrieve_user_by_barcode
1057
1058     $user = $ils->retrieve_user_by_barcode($user_barcode, $user_idfield);
1059
1060 Do a fleshed retrieve of a patron by barcode. Return the patron if
1061 found and valid. Return a NCIP::Problem of 'Unknown User' otherwise.
1062
1063 The id field argument is used for the ProblemElement field in the
1064 NCIP::Problem object.
1065
1066 An invalid patron is one where the barcode is not found in the
1067 database, the patron is deleted, or the barcode used to retrieve the
1068 patron is not active. The problem element is also returned if an error
1069 occurs during the retrieval.
1070
1071 =cut
1072
1073 sub retrieve_user_by_barcode {
1074     my ($self, $barcode, $idfield) = @_;
1075     my $result = $U->simplereq(
1076         'open-ils.actor',
1077         'open-ils.actor.user.fleshed.retrieve_by_barcode',
1078         $self->{session}->{authtoken},
1079         $barcode,
1080         1
1081     );
1082
1083     # Check for a failure, or a deleted, inactive, or expired user,
1084     # and if so, return empty userdata.
1085     if (!$result || $U->event_code($result) || $U->is_true($result->deleted())
1086             || !grep {$_->barcode() eq $barcode && $U->is_true($_->active())} @{$result->cards()}) {
1087
1088         my $problem = NCIP::Problem->new();
1089         $problem->ProblemType('Unknown User');
1090         $problem->ProblemDetail("User with barcode $barcode unknown");
1091         $problem->ProblemElement($idfield);
1092         $problem->ProblemValue($barcode);
1093         $result = $problem;
1094     }
1095
1096     return $result;
1097 }
1098
1099 =head2 retrieve_user_by_id
1100
1101     $user = $ils->retrieve_user_by_id($id);
1102
1103 Similar to C<retrieve_user_by_barcode> but takes the user's database
1104 id rather than barcode. This is useful when you have a circulation or
1105 hold and need to get information about the user's involved in the hold
1106 or circulaiton.
1107
1108 It returns a fleshed user on success or undef on failure.
1109
1110 =cut
1111
1112 sub retrieve_user_by_id {
1113     my ($self, $id) = @_;
1114
1115     # Do a fleshed retrieve of the patron, and flesh the fields that
1116     # we would normally use.
1117     my $result = $U->simplereq(
1118         'open-ils.actor',
1119         'open-ils.actor.user.fleshed.retrieve',
1120         $self->{session}->{authtoken},
1121         $id,
1122         [ 'card', 'cards', 'standing_penalties', 'addresses', 'home_ou' ]
1123     );
1124     # Check for an error.
1125     undef($result) if ($result && $U->event_code($result));
1126
1127     return $result;
1128 }
1129
1130 =head2 check_user_for_problems
1131
1132     $problem = $ils>check_user_for_problems($user, 'HOLD, 'CIRC', 'RENEW');
1133
1134 This function checks if a user has a blocked profile or any from a
1135 list of provided blocks. If it does, then a NCIP::Problem object is
1136 returned, otherwise an undefined value is returned.
1137
1138 The list of blocks appears as additional arguments after the user. You
1139 can provide any value(s) that might appear in a standing penalty block
1140 lit in Evergreen. The example above checks for HOLD, CIRC, and
1141 RENEW. Any number of such values can be provided. If none are
1142 provided, the function only checks if the patron's profiles appears in
1143 the object's blocked profiles list.
1144
1145 It stops on the first matching block, if any.
1146
1147 =cut
1148
1149 sub check_user_for_problems {
1150     my $self = shift;
1151     my $user = shift;
1152     my @blocks = @_;
1153
1154     # Fill this in if we have a problem, otherwise just return it.
1155     my $problem;
1156
1157     # First, check the user's profile.
1158     if (grep {$_->id() == $user->profile()} @{$self->{blocked_profiles}}) {
1159         $problem = NCIP::Problem->new(
1160             {
1161                 ProblemType => 'User Blocked',
1162                 ProblemDetail => 'User blocked from inter-library loan',
1163                 ProblemElement => 'NULL',
1164                 ProblemValue => 'NULL'
1165             }
1166         );
1167     }
1168
1169     # Next, check if the patron has one of the indicated blocks.
1170     unless ($problem) {
1171         foreach my $block (@blocks) {
1172             if (grep {$_->standing_penalty->block_list() =~ /$block/} @{$user->standing_penalties()}) {
1173                 $problem = NCIP::Problem->new(
1174                     {
1175                         ProblemType => 'User Blocked',
1176                         ProblemDetail => 'User blocked from ' .
1177                             ($block eq 'HOLD') ? 'holds' : (($block eq 'RENEW') ? 'renewals' :
1178                                                                 (($block eq 'CIRC') ? 'checkout' : lc($block))),
1179                         ProblemElement => 'NULL',
1180                         ProblemValue => 'NULL'
1181                     }
1182                 );
1183                 last;
1184             }
1185         }
1186     }
1187
1188     return $problem;
1189 }
1190
1191 =head2 check_circ_details
1192
1193     $problem = $ils->check_circ_details($circ, $copy, $user);
1194
1195 Checks if we can checkin or renew a circulation. That is, the
1196 circulation is still open (i.e. the copy is still checked out), if we
1197 either own the copy or are the circulation location, and if the
1198 circulation is for the optional $user argument. $circ and $copy are
1199 required. $user is optional.
1200
1201 Returns a problem if any of the above conditions fail. Returns undef
1202 if they pass and we can proceed with the checkin or renewal.
1203
1204 If the failure occurred on the copy-related checks, then the
1205 ProblemElement field will be undefined and needs to be filled in with
1206 the item id field name. If the check for the copy being checked out to
1207 the provided user fails, then both ProblemElement and ProblemValue
1208 fields will be empty and need to be filled in by the caller.
1209
1210 =cut
1211
1212 sub check_circ_details {
1213     my ($self, $circ, $copy, $user) = @_;
1214
1215     # Shortcut for the next check.
1216     my $ou_id = $self->{session}->{work_ou}->id();
1217
1218     if (!$circ || $circ->checkin_time() || ($circ->circ_lib() != $ou_id && $copy->circ_lib() != $ou_id)) {
1219         # Item isn't checked out.
1220         return NCIP::Problem->new(
1221             {
1222                 ProblemType => 'Item Not Checked Out',
1223                 ProblemDetail => 'Item with barcode ' . $copy->barcode() . ' is not checked out.',
1224                 ProblemValue => $copy->barcode()
1225             }
1226         );
1227     } else {
1228         # Get data on the patron who has it checked out.
1229         my $circ_user = $self->retrieve_user_by_id($circ->usr());
1230         if ($user && $circ_user && $user->id() != $circ_user->id()) {
1231             # The ProblemElement and ProblemValue field need to be
1232             # filled in by the caller.
1233             return NCIP::Problem->new(
1234                 {
1235                     ProblemType => 'Item Not Checked Out To This User',
1236                     ProblemDetail => 'Item with barcode ' . $copy->barcode() . ' is not checked out to this user.',
1237                 }
1238             );
1239         }
1240     }
1241     # If we get here, we're good to go.
1242     return undef;
1243 }
1244
1245 =head2 retrieve_copy_details_by_barcode
1246
1247     $copy = $ils->retrieve_copy_details_by_barcode($copy_barcode);
1248
1249 Look up and retrieve some copy details by the copy barcode. This
1250 method returns either a hashref with the copy details or undefined if
1251 no copy exists with that barcode or if some error occurs.
1252
1253 The hashref has the fields copy, hold, transit, circ, volume, and mvr.
1254
1255 This method differs from C<retrieve_user_by_barcode> in that a copy
1256 cannot be invalid if it exists and it is not always an error if no
1257 copy exists. In some cases, when handling AcceptItem, we might prefer
1258 there to be no copy.
1259
1260 =cut
1261
1262 sub retrieve_copy_details_by_barcode {
1263     my $self = shift;
1264     my $barcode = shift;
1265
1266     my $copy = $U->simplereq(
1267         'open-ils.circ',
1268         'open-ils.circ.copy_details.retrieve.barcode',
1269         $self->{session}->{authtoken},
1270         $barcode
1271     );
1272
1273     # If $copy is an event, return undefined.
1274     if ($copy && $U->event_code($copy)) {
1275         undef($copy);
1276     }
1277
1278     return $copy;
1279 }
1280
1281 =head2 retrieve_org_unit_by_shortname
1282
1283     $org_unit = $ils->retrieve_org_unit_by_shortname($shortname);
1284
1285 Retrieves an org. unit from the database by shortname. Returns the
1286 org. unit as a Fieldmapper object or undefined.
1287
1288 =cut
1289
1290 sub retrieve_org_unit_by_shortname {
1291     my $self = shift;
1292     my $shortname = shift;
1293
1294     my $aou = $U->simplereq(
1295         'open-ils.pcrud',
1296         'open-ils.pcrud.search.aou',
1297         $self->{session}->{authtoken},
1298         {shortname => {'=' => {transform => 'lower', value => ['lower', $shortname]}}}
1299     );
1300
1301     return $aou;
1302 }
1303
1304 =head2 retrieve_copy_location
1305
1306     $location = $ils->retrieve_copy_location($location_id);
1307
1308 Retrive a copy location based on id.
1309
1310 =cut
1311
1312 sub retrieve_copy_location {
1313     my $self = shift;
1314     my $id = shift;
1315
1316     my $location = $U->simplereq(
1317         'open-ils.pcrud',
1318         'open-ils.pcrud.retrieve.acpl',
1319         $self->{session}->{authtoken},
1320         $id
1321     );
1322
1323     return $location;
1324 }
1325
1326 =head2 create_precat_copy
1327
1328     $item_info->{
1329         barcode => '312340123456789',
1330         author => 'Public, John Q.',
1331         title => 'Magnum Opus',
1332         call_number => '005.82',
1333         publisher => 'Brick House',
1334         publication_date => '2014'
1335     };
1336
1337     $item = $ils->create_precat_copy($item_info);
1338
1339
1340 Create a "precat" copy to use for the incoming item using a hashref of
1341 item information. At a minimum, the barcode, author and title fields
1342 need to be filled in. The other fields are ignored if provided.
1343
1344 This method is called by the AcceptItem handler if the C<use_precats>
1345 configuration option is turned on.
1346
1347 =cut
1348
1349 sub create_precat_copy {
1350     my $self = shift;
1351     my $item_info = shift;
1352
1353     my $item = Fieldmapper::asset::copy->new();
1354     $item->barcode($item_info->{barcode});
1355     $item->call_number(OILS_PRECAT_CALL_NUMBER);
1356     $item->dummy_title($item_info->{title});
1357     $item->dummy_author($item_info->{author});
1358     $item->circ_lib($self->{session}->{work_ou}->id());
1359     $item->circulate('t');
1360     $item->holdable('t');
1361     $item->opac_visible('f');
1362     $item->deleted('f');
1363     $item->fine_level(OILS_PRECAT_COPY_FINE_LEVEL);
1364     $item->loan_duration(OILS_PRECAT_COPY_LOAN_DURATION);
1365     $item->location(1);
1366     $item->status(0);
1367     $item->editor($self->{session}->{user}->id());
1368     $item->creator($self->{session}->{user}->id());
1369     $item->isnew(1);
1370
1371     # Actually create it:
1372     my $xact;
1373     my $ses = OpenSRF::AppSession->create('open-ils.pcrud');
1374     $ses->connect();
1375     eval {
1376         $xact = $ses->request(
1377             'open-ils.pcrud.transaction.begin',
1378             $self->{session}->{authtoken}
1379         )->gather(1);
1380         $item = $ses->request(
1381             'open-ils.pcrud.create.acp',
1382             $self->{session}->{authtoken},
1383             $item
1384         )->gather(1);
1385         $xact = $ses->request(
1386             'open-ils.pcrud.transaction.commit',
1387             $self->{session}->{authtoken}
1388         )->gather(1);
1389     };
1390     if ($@) {
1391         undef($item);
1392         if ($xact) {
1393             eval {
1394                 $ses->request(
1395                     'open-ils.pcrud.transaction.rollback',
1396                     $self->{session}->{authtoken}
1397                 )->gather(1);
1398             };
1399         }
1400     }
1401     $ses->disconnect();
1402
1403     return $item;
1404 }
1405
1406 =head2 create_fuller_copy
1407
1408     $item_info->{
1409         barcode => '31234003456789',
1410         author => 'Public, John Q.',
1411         title => 'Magnum Opus',
1412         call_number => '005.82',
1413         publisher => 'Brick House',
1414         publication_date => '2014'
1415     };
1416
1417     $item = $ils->create_fuller_copy($item_info);
1418
1419 Creates a skeletal bibliographic record, call number, and copy for the
1420 incoming item using a hashref with item information in it. At a
1421 minimum, the barcode, author, title, and call_number fields must be
1422 filled in.
1423
1424 This method is used by the AcceptItem handler if the C<use_precats>
1425 configuration option is NOT set.
1426
1427 =cut
1428
1429 sub create_fuller_copy {
1430     my $self = shift;
1431     my $item_info = shift;
1432
1433     my $item;
1434
1435     # We do everything in one transaction, because it should be atomic.
1436     my $ses = OpenSRF::AppSession->create('open-ils.pcrud');
1437     $ses->connect();
1438     my $xact;
1439     eval {
1440         $xact = $ses->request(
1441             'open-ils.pcrud.transaction.begin',
1442             $self->{session}->{authtoken}
1443         )->gather(1);
1444     };
1445     if ($@) {
1446         undef($xact);
1447     }
1448
1449     # The rest depends on there being a transaction.
1450     if ($xact) {
1451
1452         # Create the MARC record.
1453         my $record = MARC::Record->new();
1454         $record->encoding('UTF-8');
1455         $record->leader('00881nam a2200193   4500');
1456         my $datespec = strftime("%Y%m%d%H%M%S.0", localtime);
1457         my @fields = ();
1458         push(@fields, MARC::Field->new('005', $datespec));
1459         push(@fields, MARC::Field->new('082', '0', '4', 'a' => $item_info->{call_number}));
1460         push(@fields, MARC::Field->new('245', '0', '0', 'a' => $item_info->{title}));
1461         # Publisher is a little trickier:
1462         if ($item_info->{publisher}) {
1463             my $pub = MARC::Field->new('260', ' ', ' ', 'a' => '[S.l.]', 'b' => $item_info->{publisher});
1464             $pub->add_subfields('c' => $item_info->{publication_date}) if ($item_info->{publication_date});
1465             push(@fields, $pub);
1466         }
1467         # We have no idea if the author is personal corporate or something else, so we use a 720.
1468         push(@fields, MARC::Field->new('720', ' ', ' ', 'a' => $item_info->{author}, '4' => 'aut'));
1469         $record->append_fields(@fields);
1470         my $marc = clean_marc($record);
1471
1472         # Create the bib object.
1473         my $bib = Fieldmapper::biblio::record_entry->new();
1474         $bib->creator($self->{session}->{user}->id());
1475         $bib->editor($self->{session}->{user}->id());
1476         $bib->source($self->{bib_source}->id());
1477         $bib->active('t');
1478         $bib->deleted('f');
1479         $bib->marc($marc);
1480         $bib->isnew(1);
1481
1482         eval {
1483             $bib = $ses->request(
1484                 'open-ils.pcrud.create.bre',
1485                 $self->{session}->{authtoken},
1486                 $bib
1487             )->gather(1);
1488         };
1489         if ($@) {
1490             undef($bib);
1491             eval {
1492                 $ses->request(
1493                     'open-ils.pcrud.transaction.rollback',
1494                     $self->{session}->{authtoken}
1495                 )->gather(1);
1496             };
1497         }
1498
1499         # Create the call number
1500         my $acn;
1501         if ($bib) {
1502             $acn = Fieldmapper::asset::call_number->new();
1503             $acn->creator($self->{session}->{user}->id());
1504             $acn->editor($self->{session}->{user}->id());
1505             $acn->label($item_info->{call_number});
1506             $acn->record($bib->id());
1507             $acn->owning_lib($self->{session}->{work_ou}->id());
1508             $acn->deleted('f');
1509             $acn->isnew(1);
1510
1511             eval {
1512                 $acn = $ses->request(
1513                     'open-ils.pcrud.create.acn',
1514                     $self->{session}->{authtoken},
1515                     $acn
1516                 )->gather(1);
1517             };
1518             if ($@) {
1519                 undef($acn);
1520                 eval {
1521                     $ses->request(
1522                         'open-ils.pcrud.transaction.rollback',
1523                         $self->{session}->{authtoken}
1524                     )->gather(1);
1525                 };
1526             }
1527         }
1528
1529         # create the copy
1530         if ($acn) {
1531             $item = Fieldmapper::asset::copy->new();
1532             $item->barcode($item_info->{barcode});
1533             $item->call_number($acn->id());
1534             $item->circ_lib($self->{session}->{work_ou}->id);
1535             $item->circulate('t');
1536             if ($self->{config}->{items}->{use_force_holds}) {
1537                 $item->holdable('f');
1538             } else {
1539                 $item->holdable('t');
1540             }
1541             $item->opac_visible('f');
1542             $item->deleted('f');
1543             $item->fine_level(OILS_PRECAT_COPY_FINE_LEVEL);
1544             $item->loan_duration(OILS_PRECAT_COPY_LOAN_DURATION);
1545             $item->location(1);
1546             $item->status(0);
1547             $item->editor($self->{session}->{user}->id);
1548             $item->creator($self->{session}->{user}->id);
1549             $item->isnew(1);
1550
1551             eval {
1552                 $item = $ses->request(
1553                     'open-ils.pcrud.create.acp',
1554                     $self->{session}->{authtoken},
1555                     $item
1556                 )->gather(1);
1557
1558                 # Cross our fingers and commit the work.
1559                 $xact = $ses->request(
1560                     'open-ils.pcrud.transaction.commit',
1561                     $self->{session}->{authtoken}
1562                 )->gather(1);
1563             };
1564             if ($@) {
1565                 undef($item);
1566                 eval {
1567                     $ses->request(
1568                         'open-ils.pcrud.transaction.rollback',
1569                         $self->{session}->{authtoken}
1570                     )->gather(1) if ($xact);
1571                 };
1572             }
1573         }
1574     }
1575
1576     # We need to disconnect our session.
1577     $ses->disconnect();
1578
1579     # Now, we handle our asset stat_cat entries.
1580     if ($item) {
1581         # It would be nice to do these in the above transaction, but
1582         # pcrud does not support the ascecm object, yet.
1583         foreach my $entry (@{$self->{stat_cat_entries}}) {
1584             my $map = Fieldmapper::asset::stat_cat_entry_copy_map->new();
1585             $map->isnew(1);
1586             $map->stat_cat($entry->stat_cat());
1587             $map->stat_cat_entry($entry->id());
1588             $map->owning_copy($item->id());
1589             # We don't really worry if it succeeds or not.
1590             $U->simplereq(
1591                 'open-ils.circ',
1592                 'open-ils.circ.stat_cat.asset.copy_map.create',
1593                 $self->{session}->{authtoken},
1594                 $map
1595             );
1596         }
1597     }
1598
1599     return $item;
1600 }
1601
1602 =head2 place_hold
1603
1604     $hold = $ils->place_hold($item, $user, $location);
1605
1606 This function places a hold on $item for $user for pickup at
1607 $location. If location is not provided or undefined, the user's home
1608 library is used as a fallback.
1609
1610 $item can be a copy (asset::copy), volume (asset::call_number), or bib
1611 (biblio::record_entry). The appropriate hold type will be placed
1612 depending on the object.
1613
1614 On success, the method returns the object representing the hold. On
1615 failure, a NCIP::Problem object, describing the failure, is returned.
1616
1617 =cut
1618
1619 sub place_hold {
1620     my $self = shift;
1621     my $item = shift;
1622     my $user = shift;
1623     my $location = shift;
1624
1625     # If $location is undefined, use the user's home_ou, which should
1626     # have been fleshed when the user was retrieved.
1627     $location = $user->home_ou() unless ($location);
1628
1629     # $hold is the hold. $params is for the is_possible check.
1630     my ($hold, $params);
1631
1632     # Prep the hold with fields common to all hold types:
1633     $hold = Fieldmapper::action::hold_request->new();
1634     $hold->isnew(1); # Just to make sure.
1635     $hold->target($item->id());
1636     $hold->usr($user->id());
1637     $hold->pickup_lib($location->id());
1638     if (!$user->email()) {
1639         $hold->email_notify('f');
1640         $hold->phone_notify($user->day_phone()) if ($user->day_phone());
1641     } else {
1642         $hold->email_notify('t');
1643     }
1644
1645     # Ditto the params:
1646     $params = { pickup_lib => $location->id(), patronid => $user->id() };
1647
1648     if (ref($item) eq 'Fieldmapper::asset::copy') {
1649         my $type = ($self->{config}->{items}->{use_force_holds}) ? 'F' : 'C';
1650         $hold->hold_type($type);
1651         $hold->current_copy($item->id());
1652         $params->{hold_type} = $type;
1653         $params->{copy_id} = $item->id();
1654     } elsif (ref($item) eq 'Fieldmapper::asset::call_number') {
1655         $hold->hold_type('V');
1656         $params->{hold_type} = 'V';
1657         $params->{volume_id} = $item->id();
1658     } elsif (ref($item) eq 'Fieldmapper::biblio::record_entry') {
1659         $hold->hold_type('T');
1660         $params->{hold_type} = 'T';
1661         $params->{titleid} = $item->id();
1662     }
1663
1664     # Check if the hold is possible:
1665     my $r = $U->simplereq(
1666         'open-ils.circ',
1667         'open-ils.circ.title_hold.is_possible',
1668         $self->{session}->{authtoken},
1669         $params
1670     );
1671
1672     if ($r->{success}) {
1673         $hold = $U->simplereq(
1674             'open-ils.circ',
1675             'open-ils.circ.holds.create.override',
1676             $self->{session}->{authtoken},
1677             $hold
1678         );
1679         if (ref($hold) eq 'HASH') {
1680             $hold = _problem_from_event('Request Not Possible', $hold);
1681         }
1682     } elsif ($r->{last_event}) {
1683         $hold = _problem_from_event('Request Not Possible', $r->{last_event});
1684     } elsif ($r->{textcode}) {
1685         $hold = _problem_from_event('Request Not Possible', $r);
1686     } else {
1687         $hold = _problem_from_event('Request Not Possible');
1688     }
1689
1690     return $hold;
1691 }
1692
1693 =head2 delete_copy
1694
1695     $ils->delete_copy($copy);
1696
1697 Deletes the copy, and if it is owned by our work_ou and not a precat,
1698 we also delete the volume and bib on which the copy depends.
1699
1700 =cut
1701
1702 sub delete_copy {
1703     my $self = shift;
1704     my $copy = shift;
1705
1706     # Shortcut for ownership checks below.
1707     my $ou_id = $self->{session}->{work_ou}->id();
1708
1709     # First, make sure the copy is not already deleted and we own it.
1710     return undef if ($U->is_true($copy->deleted()) || $copy->circ_lib() != $ou_id);
1711
1712     # Indicate we want to delete the copy.
1713     $copy->isdeleted(1);
1714
1715     # Delete the copy using a backend call that will delete the copy,
1716     # the call number, and bib when appropriate.
1717     my $result = $U->simplereq(
1718         'open-ils.cat',
1719         'open-ils.cat.asset.copy.fleshed.batch.update.override',
1720         $self->{session}->{authtoken},
1721         [$copy]
1722     );
1723
1724     # We are currently not checking for succes or failure of the
1725     # above. At some point, someone may want to.
1726
1727     return undef;
1728 }
1729
1730 =head2 copy_can_circulate
1731
1732     $can_circulate = $ils->copy_can_circulate($copy);
1733
1734 Check if the copy's location and the copy itself allow
1735 circulation. Return true if they do, and false if they do not.
1736
1737 =cut
1738
1739 sub copy_can_circulate {
1740     my $self = shift;
1741     my $copy = shift;
1742
1743     my $location = $copy->location();
1744     unless (ref($location)) {
1745         $location = $self->retrieve_copy_location($location);
1746     }
1747
1748     return ($U->is_true($copy->circulate()) && $U->is_true($location->circulate()));
1749 }
1750
1751 =head2 copy_can_fulfill
1752
1753     $can_fulfill = $ils->copy_can_fulfill($copy);
1754
1755 Check if the copy's location and the copy itself allow
1756 holds. Return true if they do, and false if they do not.
1757
1758 =cut
1759
1760 sub copy_can_fulfill {
1761     my $self = shift;
1762     my $copy = shift;
1763
1764     my $location = $copy->location();
1765     unless (ref($location)) {
1766         $location = $self->retrieve_copy_location($location);
1767     }
1768
1769     return ($U->is_true($copy->holdable()) && $U->is_true($location->holdable()));
1770 }
1771
1772 =head1 OVERRIDDEN PARENT METHODS
1773
1774 =head2 find_user_barcode
1775
1776 We dangerously override our parent's C<find_user_barcode> to return
1777 either the $barcode or a Problem object. In list context the barcode
1778 or problem will be the first argument and the id field, if any, will
1779 be the second. We also add a second, optional, argument to indicate a
1780 default value for the id field in the event of a failure to find
1781 anything at all. (Perl lets us get away with this.)
1782
1783 =cut
1784
1785 sub find_user_barcode {
1786     my $self = shift;
1787     my $request = shift;
1788     my $default = shift;
1789
1790     unless ($default) {
1791         my $message = $self->parse_request_type($request);
1792         if ($message eq 'LookupUser') {
1793             $default = 'AuthenticationInputData';
1794         } else {
1795             $default = 'UserIdentifierValue';
1796         }
1797     }
1798
1799     my ($value, $idfield) = $self->SUPER::find_user_barcode($request);
1800
1801     unless ($value) {
1802         $idfield = $default unless ($idfield);
1803         $value = NCIP::Problem->new();
1804         $value->ProblemType('Needed Data Missing');
1805         $value->ProblemDetail('Cannot find user barcode in message.');
1806         $value->ProblemElement($idfield);
1807         $value->ProblemValue('NULL');
1808     }
1809
1810     return (wantarray) ? ($value, $idfield) : $value;
1811 }
1812
1813 =head2 find_item_barcode
1814
1815 We do pretty much the same thing as with C<find_user_barcode> for
1816 C<find_item_barcode>.
1817
1818 =cut
1819
1820 sub find_item_barcode {
1821     my $self = shift;
1822     my $request = shift;
1823     my $default = shift || 'ItemIdentifierValue';
1824
1825     my ($value, $idfield) = $self->SUPER::find_item_barcode($request);
1826
1827     unless ($value) {
1828         $idfield = $default unless ($idfield);
1829         $value = NCIP::Problem->new();
1830         $value->ProblemType('Needed Data Missing');
1831         $value->ProblemDetail('Cannot find item barcode in message.');
1832         $value->ProblemElement($idfield);
1833         $value->ProblemValue('NULL');
1834     }
1835
1836     return (wantarray) ? ($value, $idfield) : $value;
1837 }
1838
1839 # private subroutines not meant to be used directly by subclasses.
1840 # Most have to do with setup and/or state checking of implementation
1841 # components.
1842
1843 # Find, load, and parse our configuration file:
1844 sub _configure {
1845     my $self = shift;
1846
1847     # Find the configuration file via variables:
1848     my $file = OILS_NCIP_CONFIG_DEFAULT;
1849     $file = $ENV{OILS_NCIP_CONFIG} if ($ENV{OILS_NCIP_CONFIG});
1850
1851     $self->{config} = XMLin($file, NormaliseSpace => 2,
1852                             ForceArray => ['block_profile', 'stat_cat_entry']);
1853 }
1854
1855 # Bootstrap OpenSRF::System and load the IDL.
1856 sub _bootstrap {
1857     my $self = shift;
1858
1859     my $bootstrap_config = $self->{config}->{bootstrap};
1860     OpenSRF::System->bootstrap_client(config_file => $bootstrap_config);
1861
1862     my $idl = OpenSRF::Utils::SettingsClient->new->config_value("IDL");
1863     Fieldmapper->import(IDL => $idl);
1864 }
1865
1866 # Login and then initialize some object data based on the
1867 # configuration.
1868 sub _init {
1869     my $self = shift;
1870
1871     # Login to Evergreen.
1872     $self->login();
1873
1874     # Load the barred groups as pgt objects into a blocked_profiles
1875     # list.
1876     $self->{blocked_profiles} = [];
1877     foreach (@{$self->{config}->{patrons}->{block_profile}}) {
1878         my $pgt;
1879         if (ref $_) {
1880             $pgt = $U->simplereq(
1881                 'open-ils.pcrud',
1882                 'open-ils.pcrud.retrieve.pgt',
1883                 $self->{session}->{authtoken},
1884                 $_->{grp}
1885             );
1886         } else {
1887             $pgt = $U->simplereq(
1888                 'open-ils.pcrud',
1889                 'open-ils.pcrud.search.pgt',
1890                 $self->{session}->{authtoken},
1891                 {name => $_}
1892             );
1893         }
1894         push(@{$self->{blocked_profiles}}, $pgt) if ($pgt);
1895     }
1896
1897     # Load the bib source if we're not using precats.
1898     unless ($self->{config}->{items}->{use_precats}) {
1899         # Retrieve the default
1900         $self->{bib_source} = $U->simplereq(
1901             'open-ils.pcrud',
1902             'open-ils.pcrud.retrieve.cbs',
1903             $self->{session}->{authtoken},
1904             BIB_SOURCE_DEFAULT);
1905         my $data = $self->{config}->{items}->{bib_source};
1906         if ($data) {
1907             $data = $data->[0] if (ref($data) eq 'ARRAY');
1908             my $result;
1909             if (ref $data) {
1910                 $result = $U->simplereq(
1911                     'open-ils.pcrud',
1912                     'open-ils.pcrud.retrieve.cbs',
1913                     $self->{session}->{authtoken},
1914                     $data->{cbs}
1915                 );
1916             } else {
1917                 $result = $U->simplereq(
1918                     'open-ils.pcrud',
1919                     'open-ils.pcrud.search.cbs',
1920                     $self->{session}->{authtoken},
1921                     {source => $data}
1922                 );
1923             }
1924             $self->{bib_source} = $result if ($result);
1925         }
1926     }
1927
1928     # Load the required asset.stat_cat_entries:
1929     $self->{stat_cat_entries} = [];
1930     # First, make a regex for our ou and ancestors:
1931     my $ancestors = join("|", @{$U->get_org_ancestors($self->{session}->{work_ou}->id())});
1932     my $re = qr/(?:$ancestors)/;
1933     # Get the uniq stat_cat ids from the configuration:
1934     my @cats = uniq map {$_->{stat_cat}} @{$self->{config}->{items}->{stat_cat_entry}};
1935     # Retrieve all of the fleshed stat_cats and entries for the above.
1936     my $stat_cats = $U->simplereq(
1937         'open-ils.circ',
1938         'open-ils.circ.stat_cat.asset.retrieve.batch',
1939         $self->{session}->{authtoken},
1940         @cats
1941     );
1942     foreach my $entry (@{$self->{config}->{items}->{stat_cat_entry}}) {
1943         # Must have the stat_cat attr and the name, so we must have a
1944         # reference.
1945         next unless(ref $entry);
1946         my ($stat) = grep {$_->id() == $entry->{stat_cat}} @$stat_cats;
1947         push(@{$self->{stat_cat_entries}}, grep {$_->owner() =~ $re && $_->value() eq $entry->{content}} @{$stat->entries()});
1948     }
1949 }
1950
1951 # Standalone, "helper" functions.  These do not take an object or
1952 # class reference.
1953
1954 # Check if a user is past their expiration date.
1955 sub _expired {
1956     my $user = shift;
1957     my $expired = 0;
1958
1959     # Users might not expire.  If so, they have no expire_date.
1960     if ($user->expire_date()) {
1961         my $expires = DateTime::Format::ISO8601->parse_datetime(
1962             cleanse_ISO8601($user->expire_date())
1963         )->epoch();
1964         my $now = DateTime->now()->epoch();
1965         $expired = $now > $expires;
1966     }
1967
1968     return $expired;
1969 }
1970
1971 # Creates a NCIP Problem from an event. Takes a string for the problem
1972 # type, the event hashref (or a string to use for the detail), and
1973 # optional arguments for the ProblemElement and ProblemValue fields.
1974 sub _problem_from_event {
1975     my ($type, $evt, $element, $value) = @_;
1976
1977     my $detail;
1978
1979     # Check the event.
1980     if (ref($evt)) {
1981         my ($textcode, $desc);
1982
1983         # Get the textcode, if available. We favor those defined in
1984         # ils_events.xml over those made up on the fly.
1985         if ($evt->{ilsevent} && $evt->{ilsevent}->{textcode}) {
1986             $textcode = $evt->{ilsevent}->{textcode};
1987         } elsif ($evt->{textcode}) {
1988             $textcode = $evt->{textcode};
1989         }
1990
1991         # Get the description. We favor translated descriptions over
1992         # the English in ils_events.xml.
1993         if ($evt->{desc}) {
1994             $desc = $evt->{desc};
1995         } elsif ($evt->{ilsevent} && $evt->{ilsevent}->{desc}) {
1996             $desc = $evt->{ilsevent}->{desc};
1997         }
1998
1999         # Check if $type was set. As an "undocumented" feature, you
2000         # can pass undef, and we'll use the textcode from the event.
2001         unless ($type) {
2002             if ($textcode) {
2003                 $type = $textcode;
2004             }
2005         }
2006
2007         # Set the detail from some combination of the above.
2008         if ($desc) {
2009             $detail = $desc;
2010         } elsif ($textcode eq 'PERM_FAILURE') {
2011             if ($evt->{ilsperm}) {
2012                 $detail = "Permission denied: " . $evt->{ilsperm};
2013                 $detail =~ s/\.override$//;
2014             }
2015         } elsif ($textcode) {
2016             $detail = "ILS returned $textcode error.";
2017         } else {
2018             $detail = 'Detail not available.';
2019         }
2020
2021     } else {
2022         $detail = $evt;
2023     }
2024
2025     return NCIP::Problem->new(
2026         {
2027             ProblemType => ($type) ? $type : 'Temporary Processing Failure',
2028             ProblemDetail => ($detail) ? $detail : 'Detail not available.',
2029             ProblemElement => ($element) ? $element : 'NULL',
2030             ProblemValue => ($value) ? $value : 'NULL'
2031         }
2032     );
2033 }
2034
2035 1;