Open-ILS/src/perlmods/OpenILS/Application/Search/Biblio.pm

   1 package OpenILS::Application::Search::Biblio;
   2 use base qw/OpenSRF::Application/;
   3 use strict; use warnings;
   4
   5 use OpenILS::EX;
   6
   7 use JSON;
   8 use OpenILS::Utils::Fieldmapper;
   9 use OpenILS::Utils::ModsParser;
  10 use OpenSRF::Utils::SettingsClient;
  11
  12 use OpenILS::Application::AppUtils;
  13
  14 use JSON;
  15
  16 use Time::HiRes qw(time);
  17 use OpenSRF::EX qw(:try);
  18 use Digest::MD5 qw(md5_hex);
  19
  20 use XML::LibXML;
  21 use XML::LibXSLT;
  22
  23 my $apputils = "OpenILS::Application::AppUtils";
  24
  25 # Houses biblio search utilites
  26
  27
  28 __PACKAGE__->register_method(
  29         method  => "test",
  30         api_name        => "open-ils.search.test");
  31
  32 sub test { return "test"; }
  33
  34
  35
  36 __PACKAGE__->register_method(
  37         method  => "biblio_search_marc",
  38         api_name        => "open-ils.search.biblio.marc",
  39         argc            => 1,
  40         note            => "Searches biblio information by marc tag",
  41 );
  42
  43 sub biblio_search_marc {
  44
  45         my( $self, $client, $search_hash, $string ) = @_;
  46
  47         warn "Building biblio marc session\n";
  48         my $session = OpenSRF::AppSession->create("open-ils.storage");
  49
  50         use Data::Dumper;
  51         warn "Sending biblio marc request. String $string\nSearch hash: " . Dumper($search_hash);
  52         my $request = $session->request(
  53                         "open-ils.storage.direct.metabib.full_rec.search_fts.index_vector.atomic",
  54                         restrict => $search_hash,
  55                         term            => $string );
  56         my $data = $request->gather(1);
  57
  58         warn Dumper $data;
  59
  60         $session->finish();
  61         $session->disconnect();
  62
  63         return $data;
  64
  65 }
  66
  67
  68
  69 # ---------------------------------------------------------------------------
  70 # takes a list of record id's and turns the docs into friendly
  71 # mods structures. Creates one MODS structure for each doc id.
  72 # ---------------------------------------------------------------------------
  73 sub _records_to_mods {
  74         my @ids = @_;
  75
  76         my @results;
  77         my @marcxml_objs;
  78
  79         my $session = OpenSRF::AppSession->create("open-ils.storage");
  80         my $request = $session->request(
  81                         "open-ils.storage.direct.biblio.record_entry.batch.retrieve",  @ids );
  82
  83         my $last_content = undef;
  84
  85         while( my $response = $request->recv() ) {
  86
  87                 if( $last_content ) {
  88                         my $u = OpenILS::Utils::ModsParser->new();
  89                         $u->start_mods_batch( $last_content->marc );
  90                         my $mods = $u->finish_mods_batch();
  91                         $mods->doc_id($last_content->id());
  92                         warn "Turning doc " . $mods->doc_id() . " into MODS\n";
  93                         $last_content = undef;
  94                         push @results, $mods;
  95                 }
  96
  97                 next unless $response;
  98
  99                 if($response->isa("OpenSRF::EX")) {
 100                         throw $response ($response->stringify);
 101                 }
 102
 103                 $last_content = $response->content;
 104
 105         }
 106
 107         if( $last_content ) {
 108                 my $u = OpenILS::Utils::ModsParser->new();
 109                 $u->start_mods_batch( $last_content->marc );
 110                 my $mods = $u->finish_mods_batch();
 111                 $mods->doc_id($last_content->id());
 112                 push @results, $mods;
 113         }
 114
 115         $request->finish();
 116         $session->finish();
 117         $session->disconnect();
 118
 119         return \@results;
 120
 121 }
 122
 123 __PACKAGE__->register_method(
 124         method  => "record_id_to_mods",
 125         api_name        => "open-ils.search.biblio.record.mods.retrieve",
 126         argc            => 1,
 127         note            => "Provide ID, we provide the mods"
 128 );
 129
 130 # converts a record into a mods object with copy counts attached
 131 sub record_id_to_mods {
 132
 133         my( $self, $client, $org_id, $id ) = @_;
 134
 135         my $mods_list = _records_to_mods( $id );
 136         my $mods_obj = $mods_list->[0];
 137         my $cmethod = $self->method_lookup(
 138                         "open-ils.search.biblio.record.copy_count");
 139         my ($count) = $cmethod->run($org_id, $id);
 140         $mods_obj->copy_count($count);
 141
 142         return $mods_obj;
 143 }
 144
 145
 146
 147 __PACKAGE__->register_method(
 148         method  => "record_id_to_mods_slim",
 149         api_name        => "open-ils.search.biblio.record.mods_slim.retrieve",
 150         argc            => 1,
 151         note            => "Provide ID, we provide the mods"
 152 );
 153
 154 # converts a record into a mods object with NO copy counts attached
 155 sub record_id_to_mods_slim {
 156         my( $self, $client, $id ) = @_;
 157         return undef unless defined $id;
 158
 159         if(ref($id) and ref($id) == 'ARRAY') {
 160                 return _records_to_mods( @$id );
 161         }
 162         my $mods_list = _records_to_mods( $id );
 163         my $mods_obj = $mods_list->[0];
 164         return $mods_obj;
 165 }
 166
 167
 168 # Returns the number of copies attached to a record based on org location
 169 __PACKAGE__->register_method(
 170         method  => "record_id_to_copy_count",
 171         api_name        => "open-ils.search.biblio.record.copy_count",
 172 );
 173
 174 __PACKAGE__->register_method(
 175         method  => "record_id_to_copy_count",
 176         api_name        => "open-ils.search.biblio.metarecord.copy_count",
 177 );
 178
 179 __PACKAGE__->register_method(
 180         method  => "record_id_to_copy_count",
 181         api_name        => "open-ils.search.biblio.metarecord.copy_count.staff",
 182 );
 183 sub record_id_to_copy_count {
 184         my( $self, $client, $org_id, $record_id ) = @_;
 185
 186         my $method = "open-ils.storage.biblio.record_entry.copy_count.atomic";
 187         my $key = "record";
 188         if($self->api_name =~ /metarecord/) {
 189                 $method = "open-ils.storage.metabib.metarecord.copy_count.atomic";
 190                 $key = "metarecord";
 191         }
 192
 193         if($self->api_name =~ /staff/ ) {
 194                 $method =~ s/atomic/staff\.atomic/og;
 195                 warn "Doing staff search $method\n";
 196         }
 197
 198
 199         my $session = OpenSRF::AppSession->create("open-ils.storage");
 200         warn "copy_count retrieve $record_id\n";
 201         return undef unless(defined $record_id);
 202
 203         my $request = $session->request(
 204                 $method, org_unit => $org_id => $key => $record_id );
 205
 206
 207         my $count = $request->gather(1);
 208         $session->disconnect();
 209         return [ sort { $a->{depth} <=> $b->{depth} } @$count ];
 210
 211 }
 212
 213
 214 # used for cat search classes
 215 my $cat_search_hash =  {
 216
 217         author => [
 218                 { tag => "100", subfield => "a"} ,
 219                 { tag => "700", subfield => "a"},
 220         ],
 221
 222         title => [
 223                 { tag => "245", subfield => "a"},
 224                 { tag => "242", subfield => "a"},
 225                 { tag => "240", subfield => "a"},
 226                 { tag => "210", subfield => "a"},
 227         ],
 228
 229         subject => [
 230                 { tag => "650", subfield => "_" },
 231         ],
 232
 233         tcn     => [
 234                 { tag => "035", subfield => "_" },
 235         ],
 236
 237         isbn    => [
 238                 { tag => "020", subfield => "a" },
 239         ],
 240
 241 };
 242
 243
 244 __PACKAGE__->register_method(
 245         method  => "biblio_search_tcn",
 246         api_name        => "open-ils.search.biblio.tcn",
 247         argc            => 3,
 248         note            => "Retrieve a record by TCN",
 249 );
 250
 251 sub biblio_search_tcn {
 252
 253         my( $self, $client, $tcn ) = @_;
 254
 255         $tcn =~ s/.*?(\w+)\s*$/$1/o;
 256         warn "Searching TCN $tcn\n";
 257
 258         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
 259         my $request = $session->request(
 260                         "open-ils.storage.direct.biblio.record_entry.search.tcn_value.atomic", $tcn );
 261         my $record_entry = $request->gather(1);
 262
 263         my @ids;
 264         for my $record (@$record_entry) {
 265                 push @ids, $record->id;
 266         }
 267
 268         $session->disconnect();
 269
 270         warn "received ID's for tcn search @ids\n";
 271         my $size = @ids;
 272
 273         return { count => $size, ids => \@ids };
 274
 275 }
 276
 277
 278 # --------------------------------------------------------------------------------
 279 # ISBN
 280
 281 __PACKAGE__->register_method(
 282         method  => "biblio_search_isbn",
 283         api_name        => "open-ils.search.biblio.isbn",
 284 );
 285
 286 sub biblio_search_isbn {
 287         my( $self, $client, $isbn ) = @_;
 288         throw OpenSRF::EX::InvalidArg
 289
 290                 ("biblio_search_isbn needs an ISBN to search")
 291                         unless defined $isbn;
 292
 293         warn "biblio search for ISBN $isbn\n";
 294         my $method = $self->method_lookup("open-ils.search.biblio.marc");
 295         my ($records) = $method->run( $cat_search_hash->{isbn}, $isbn );
 296
 297         return { count => 0 } unless($records and @$records);
 298         my $size = @$records;
 299         return { count => $size, ids => $records };
 300 }
 301
 302
 303
 304 # --------------------------------------------------------------------------------
 305
 306 __PACKAGE__->register_method(
 307         method  => "biblio_barcode_to_copy",
 308         api_name        => "open-ils.search.asset.copy.find_by_barcode",
 309 );
 310
 311 # turns a barcode into a copy object
 312 sub biblio_barcode_to_copy {
 313         my( $self, $client, $barcode ) = @_;
 314
 315         throw OpenSRF::EX::InvalidArg
 316                 ("search.biblio.barcode needs a barcode to search")
 317                         unless defined $barcode;
 318
 319         warn "copy search for barcode $barcode\n";
 320         my $record = OpenILS::Application::AppUtils->simple_scalar_request(
 321                         "open-ils.storage",
 322                         "open-ils.storage.direct.asset.copy.search.barcode.atomic",
 323                         $barcode );
 324
 325         return undef unless($record);
 326         return $record->[0];
 327
 328 }
 329
 330 __PACKAGE__->register_method(
 331         method  => "biblio_id_to_copy",
 332         api_name        => "open-ils.search.asset.copy.batch.retrieve",
 333 );
 334
 335 # turns a barcode into a copy object
 336 sub biblio_id_to_copy {
 337         my( $self, $client, $ids ) = @_;
 338
 339         throw OpenSRF::EX::InvalidArg
 340                 ("search.biblio.batch.retrieve needs a id to search")
 341                         unless defined $ids;
 342
 343         warn "copy search for ids @$ids\n";
 344         my $record = OpenILS::Application::AppUtils->simple_scalar_request(
 345                         "open-ils.storage",
 346                         "open-ils.storage.direct.asset.copy.batch.retrieve.atomic",
 347                         @$ids );
 348
 349         return $record;
 350
 351 }
 352
 353
 354 __PACKAGE__->register_method(
 355         method  => "fleshed_copy_retrieve_batch",
 356         api_name        => "open-ils.search.asset.copy.fleshed.batch.retrieve",
 357 );
 358
 359 sub fleshed_copy_retrieve_batch {
 360         my( $self, $client, $ids ) = @_;
 361
 362         throw OpenSRF::EX::InvalidArg
 363                 ("search.biblio.batch.retrieve needs a id to search")
 364                         unless defined $ids;
 365
 366         warn "fleshed copy search for id @$ids\n";
 367         my $copy = OpenILS::Application::AppUtils->simple_scalar_request(
 368                         "open-ils.storage",
 369                         "open-ils.storage.fleshed.asset.copy.batch.retrieve.atomic",
 370                         @$ids );
 371
 372         return $copy;
 373 }
 374
 375 __PACKAGE__->register_method(
 376         method  => "fleshed_copy_retrieve",
 377         api_name        => "open-ils.search.asset.copy.fleshed.retrieve",
 378 );
 379
 380 sub fleshed_copy_retrieve {
 381         my( $self, $client, $id ) = @_;
 382
 383         return undef unless defined $id;
 384         warn "copy retrieve for id $id\n";
 385         return OpenILS::Application::AppUtils->simple_scalar_request(
 386                         "open-ils.storage",
 387                         "open-ils.storage.fleshed.asset.copy.retrieve.atomic",
 388                         $id );
 389 }
 390
 391
 392
 393 __PACKAGE__->register_method(
 394         method  => "biblio_barcode_to_title",
 395         api_name        => "open-ils.search.biblio.find_by_barcode",
 396 );
 397
 398 sub biblio_barcode_to_title {
 399         my( $self, $client, $barcode ) = @_;
 400
 401         if(!$barcode) {
 402                 throw OpenSRF::EX::ERROR
 403                         ("Not enough args to find_by_barcode");
 404         }
 405
 406         my $title = $apputils->simple_scalar_request(
 407                 "open-ils.storage",
 408                 "open-ils.storage.biblio.record_entry.retrieve_by_barcode",
 409                 $barcode );
 410
 411         if($title) {
 412                 return { ids => [ $title->id ], count => 1 };
 413         } else {
 414                 return { count => 0 };
 415         }
 416
 417 }
 418
 419
 420 __PACKAGE__->register_method(
 421         method  => "biblio_copy_to_mods",
 422         api_name        => "open-ils.search.biblio.copy.mods.retrieve",
 423 );
 424
 425 # takes a copy object and returns it fleshed mods object
 426 sub biblio_copy_to_mods {
 427         my( $self, $client, $copy ) = @_;
 428
 429         throw OpenSRF::EX::InvalidArgs
 430                 ("copy.mods.retrieve needs a copy") unless( $copy );
 431
 432         new Fieldmapper::asset::copy($copy);
 433
 434         my $volume = OpenILS::Application::AppUtils->simple_scalar_request(
 435                 "open-ils.storage",
 436                 "open-ils.storage.direct.asset.call_number.retrieve",
 437                 $copy->call_number() );
 438
 439         my $mods = _records_to_mods($volume->record());
 440         $mods = shift @$mods;
 441         $volume->copies([$copy]);
 442         push @{$mods->call_numbers()}, $volume;
 443
 444         return $mods;
 445 }
 446
 447
 448 sub barcode_to_mods {
 449
 450 }
 451
 452
 453 # --------------------------------------------------------------------------------
 454
 455
 456
 457 __PACKAGE__->register_method(
 458         method  => "cat_biblio_search_class",
 459         api_name        => "open-ils.search.cat.biblio.class",
 460 );
 461
 462
 463 sub cat_biblio_search_class {
 464
 465         my( $self, $client, $org_id, $class, $sort, $string ) = @_;
 466
 467         throw OpenSRF::EX::InvalidArg
 468                 ("Not enough args to open-ils.search.cat.biblio.class")
 469                         unless( defined($org_id) and $class and $sort and $string );
 470
 471
 472         my $search_hash;
 473
 474         my $method = $self->method_lookup("open-ils.search.biblio.marc");
 475         if(!$method) {
 476                 throw OpenSRF::EX::PANIC
 477                         ("Can't lookup method 'open-ils.search.biblio.marc'");
 478         }
 479
 480         my ($records) = $method->run( $cat_search_hash->{$class}, $string );
 481
 482         my @ids;
 483         for my $i (@$records) { push @ids, $i->[0]; }
 484
 485         my $mods_list = _records_to_mods( @ids );
 486         return undef unless (ref($mods_list) eq "ARRAY");
 487
 488         # ---------------------------------------------------------------
 489         # append copy count information to the mods objects
 490         my $session = OpenSRF::AppSession->create("open-ils.storage");
 491
 492         my $request = $session->request(
 493                 "open-ils.storage.direct.biblio.record_copy_count.batch",  $org_id, @ids );
 494
 495         for my $id (@ids) {
 496
 497                 warn "receiving copy counts for doc $id\n";
 498
 499                 my $response = $request->recv();
 500                 next unless $response;
 501
 502                 if( $response and UNIVERSAL::isa($response, "Error")) {
 503                         throw $response ($response->stringify);
 504                 }
 505
 506                 my $count = $response->content;
 507                 my $mods_obj = undef;
 508                 for my $m (@$mods_list) {
 509                         $mods_obj = $m if ($m->doc_id() == $id)
 510                 }
 511                 if($mods_obj) {
 512                         $mods_obj->copy_count($count);
 513                 }
 514
 515                 $client->respond( $mods_obj );
 516
 517         }
 518         $request->finish();
 519
 520         $session->finish();
 521         $session->disconnect();
 522         $session->kill_me();
 523         # ---------------------------------------------------------------
 524
 525         return undef;
 526 }
 527
 528
 529
 530
 531 __PACKAGE__->register_method(
 532         method  => "biblio_search_class_count",
 533         api_name        => "open-ils.search.biblio.class.count",
 534 );
 535
 536 __PACKAGE__->register_method(
 537         method  => "biblio_search_class_count",
 538         api_name        => "open-ils.search.biblio.class.count.staff",
 539 );
 540
 541 sub biblio_search_class_count {
 542
 543         my( $self, $client, $class, $string, $org_id, $org_type, $format ) = @_;
 544
 545         warn "org: $org_id : depth: $org_type\n";
 546
 547         $org_id         = "1" unless defined($org_id); # xxx
 548         $org_type       = 0     unless defined($org_type);
 549
 550         warn "Searching biblio.class.id\n" .
 551                 "string: $string "              .
 552                 "org_id: $org_id\n"             .
 553                 "depth: $org_type\n"            .
 554                 "format: $format\n";
 555
 556         if( !defined($org_id) or !$class or !$string ) {
 557                 warn "not enbough args to metarecord search\n";
 558                 throw OpenSRF::EX::InvalidArg
 559                         ("Not enough args to open-ils.search.cat.biblio.class")
 560         }
 561
 562         $class =~ s/\s+//g;
 563
 564         if( ($class ne "title") and ($class ne "author") and
 565                 ($class ne "subject") and ($class ne "keyword")
 566                 and ($class ne "series"  )) {
 567                 warn "Invalid search class: $class\n";
 568                 throw OpenSRF::EX::InvalidArg ("Not a valid search class: $class")
 569         }
 570
 571         # grab the mr id's from storage
 572
 573         my $method = "open-ils.storage.cachable.metabib.$class.search_fts.metarecord_count";
 574         if($self->api_name =~ /staff/) {
 575                 $method = "$method.staff";
 576                 $method =~ s/\.cachable//o;
 577         }
 578         warn "Performing count method $method\n";
 579         warn "API name " . $self->api_name() . "\n";
 580
 581         my $session = OpenSRF::AppSession->create('open-ils.storage');
 582
 583         my $request = $session->request( $method,
 584                         term                                    => $string,
 585                         org_unit                                => $org_id,
 586                         cache_page_size => 1,
 587                         depth                                   => $org_type,
 588                         format                          => $format );
 589
 590         my $count = $request->gather(1);
 591         warn "Received count $count\n";
 592
 593         return $count;
 594 }
 595
 596
 597 __PACKAGE__->register_method(
 598         method  => "biblio_search_class",
 599         api_name        => "open-ils.search.biblio.class",
 600 );
 601
 602 __PACKAGE__->register_method(
 603         method  => "biblio_search_class",
 604         api_name        => "open-ils.search.biblio.class.full",
 605 );
 606
 607 __PACKAGE__->register_method(
 608         method  => "biblio_search_class",
 609         api_name        => "open-ils.search.biblio.class.full.staff",
 610 );
 611
 612 #__PACKAGE__->register_method(
 613 #       method  => "biblio_search_class",
 614 #       api_name        => "open-ils.search.biblio.class.unordered",
 615 #);
 616
 617 __PACKAGE__->register_method(
 618         method  => "biblio_search_class",
 619         api_name        => "open-ils.search.biblio.class.staff",
 620 );
 621
 622 #__PACKAGE__->register_method(
 623 #       method  => "biblio_search_class",
 624 #       api_name        => "open-ils.search.biblio.class.unordered.staff",
 625 #);
 626
 627 sub biblio_search_class {
 628
 629         my( $self, $client, $class, $string,
 630                         $org_id, $org_type, $limit, $offset, $format ) = @_;
 631
 632         warn "org: $org_id : depth: $org_type : limit: $limit :  offset: $offset\n";
 633
 634
 635 # new method:  metabib.<class>.new_search_fts.metarecord.<staff>
 636
 637
 638         $offset         = 0     unless (defined($offset) and $offset > 0);
 639         $limit          = 100 unless (defined($limit) and $limit > 0);
 640         $org_id         = "1" unless (defined($org_id)); # xxx
 641         $org_type       = 0     unless (defined($org_type));
 642
 643         warn "Searching biblio.class.id\n" .
 644                 "string: $string "              .
 645                 "\noffset: $offset\n"   .
 646                 "limit: $limit\n"                       .
 647                 "org_id: $org_id\n"             .
 648                 "depth: $org_type\n"            .
 649                 "format: $format\n";
 650
 651         warn "Search filtering string " . time() . "\n";
 652         $string = OpenILS::Application::Search->filter_search($string);
 653         if(!$string) { return undef; }
 654
 655         if( !defined($org_id) or !$class or !$string ) {
 656                 warn "not enbough args to metarecord search\n";
 657                 throw OpenSRF::EX::InvalidArg
 658                         ("Not enough args to open-ils.search.cat.biblio.class")
 659         }
 660
 661         $class =~ s/\s+//g;
 662
 663         if( ($class ne "title") and ($class ne "author") and
 664                 ($class ne "subject") and ($class ne "keyword")
 665                 and ($class ne "series") ) {
 666                 warn "Invalid search class: $class\n";
 667                 throw OpenSRF::EX::InvalidArg ("Not a valid search class: $class")
 668         }
 669
 670         my $method = "open-ils.storage.cachable.metabib.$class.search_fts.metarecord.atomic";
 671
 672 #       if($self->api_name =~ /order/) {
 673 #               $method = "open-ils.storage.cachable.metabib.$class.search_fts.metarecord.unordered.atomic",
 674 #       }
 675
 676         if($self->api_name =~ /staff/) {
 677                 $method =~ s/atomic/staff\.atomic/og;
 678                 $method =~ s/\.cachable//o;
 679         }
 680
 681         if($self->api_name =~ /full/) {
 682                 $method =~ s/search_fts/new_search_fts/o;
 683                 $method =~ s/\.cachable//o; #XXX testing..
 684         }
 685
 686         warn "Performing search method $method\n";
 687         warn "MR search method is $method\n";
 688
 689         my $session = OpenSRF::AppSession->create('open-ils.storage');
 690
 691         warn "Search making request " . time() . "\n";
 692         my $request = $session->request(
 693                 $method,
 694                 term            => $string,
 695                 org_unit => $org_id,
 696                 depth           => $org_type,
 697                 limit           => $limit,
 698                 offset  => $offset,
 699                 format  => $format,
 700                 cache_page_size => 200,
 701                 );
 702
 703         my $records = $request->gather(1);
 704         if(!$records) {return { ids => [] }};
 705
 706         warn "Search request complete " . time() . "\n";
 707
 708         my @all_ids;
 709
 710         use Data::Dumper;
 711         warn "Received " . scalar(@$records) . " id's from class search\n";
 712
 713         # if we just get one, it won't be wrapped in an array
 714
 715         if(!ref($records->[0])) {
 716                 $records = [$records]; }
 717         for my $i (@$records) {
 718                 if(defined($i)) {
 719                         push @all_ids, $i;
 720                 }
 721         }
 722
 723         my @ids = @all_ids;
 724         @ids = grep { defined($_->[0]) } @ids;
 725
 726         $session->finish();
 727         $session->disconnect();
 728
 729         my $count = undef;
 730         if($self->api_name =~ /full/) {
 731                 if(ref($records) && $records->[0]) {
 732                         $count = $records->[0]->[3];
 733                 }
 734         }
 735
 736         return { ids => \@ids, count => $count };
 737
 738 }
 739
 740
 741
 742
 743 __PACKAGE__->register_method(
 744         method  => "biblio_mrid_to_modsbatch_batch",
 745         api_name        => "open-ils.search.biblio.metarecord.mods_slim.batch.retrieve");
 746
 747 sub biblio_mrid_to_modsbatch_batch {
 748         my( $self, $client, $mrids) = @_;
 749         warn "Performing mrid_to_modsbatch_batch...";
 750         my @mods;
 751         my $method = $self->method_lookup("open-ils.search.biblio.metarecord.mods_slim.retrieve");
 752         use Data::Dumper;
 753         warn "Grabbing mods for " . Dumper($mrids) . "\n";
 754
 755         for my $id (@$mrids) {
 756                 next unless defined $id;
 757                 #push @mods, biblio_mrid_to_modsbatch($self, $client, $id);
 758                 my ($m) = $method->run($id);
 759                 push @mods, $m;
 760         }
 761         return \@mods;
 762 }
 763
 764
 765 __PACKAGE__->register_method(
 766         method  => "biblio_mrid_to_modsbatch",
 767         api_name        => "open-ils.search.biblio.metarecord.mods_slim.retrieve");
 768
 769 __PACKAGE__->register_method(
 770         method  => "biblio_mrid_to_modsbatch",
 771         api_name        => "open-ils.search.biblio.metarecord.mods_slim.retrieve.staff");
 772
 773 sub biblio_mrid_to_modsbatch {
 774         my( $self, $client, $mrid ) = @_;
 775
 776         throw OpenSRF::EX::InvalidArg
 777                 ("search.biblio.metarecord_to_mods requires mr id")
 778                         unless defined( $mrid );
 779
 780
 781         my $metarecord = OpenILS::Application::AppUtils->simple_scalar_request( "open-ils.storage",
 782                         "open-ils.storage.direct.metabib.metarecord.retrieve", $mrid );
 783
 784         if(!$metarecord) {
 785                 throw OpenSRF::EX::ERROR ("No metarecord exists with the given id: $mrid");
 786         }
 787
 788         my $master_id = $metarecord->master_record();
 789
 790
 791         # check for existing mods
 792         if($metarecord->mods()){
 793                 warn "We already have mods for " . $metarecord->id . "\n";
 794                 my $perl = JSON->JSON2perl($metarecord->mods());
 795                 return Fieldmapper::metabib::virtual_record->new($perl);
 796         }
 797
 798
 799
 800         warn "Creating mods batch for metarecord $mrid\n";
 801         my $meth = "open-ils.search.biblio.metarecord_to_records";
 802         if( $self->api_name =~ /staff/ ) { $meth .= ".staff";}
 803         $meth = $self->method_lookup($meth);
 804
 805         my ($id_hash) = $meth->run($mrid);
 806
 807         my @ids = @{$id_hash->{ids}};
 808
 809         if(@ids < 1) { return undef; }
 810
 811         warn "Master ID is $master_id\n";
 812         # grab the master record to start the mods batch
 813
 814         $meth = "open-ils.storage.direct.biblio.record_entry.retrieve";
 815
 816         my $record = OpenILS::Application::AppUtils->simple_scalar_request( "open-ils.storage",
 817                         "open-ils.storage.direct.biblio.record_entry.retrieve", $master_id );
 818
 819         if(!$record) {
 820                 throw OpenSRF::EX::ERROR
 821                         ("No record returned with id $master_id");
 822         }
 823
 824         my $u = OpenILS::Utils::ModsParser->new();
 825         use Data::Dumper;
 826         $u->start_mods_batch( $record->marc );
 827         my $main_doc_id = $record->id();
 828
 829         @ids = grep { $_ ne $master_id } @ids;
 830
 831         # now we have to collect all of the marc objects and push them into a mods batch
 832         my $session = OpenSRF::AppSession->create("open-ils.storage");
 833         my $request = $session->request(
 834                 "open-ils.storage.direct.biblio.record_entry.batch.retrieve",  @ids );
 835
 836         while( my $response = $request->recv() ) {
 837
 838                 next unless $response;
 839                 if(UNIVERSAL::isa( $response,"OpenSRF::EX")) {
 840                         throw $response ($response->stringify);
 841                 }
 842
 843                 my $content = $response->content;
 844
 845                 if( $content ) {
 846                         $u->push_mods_batch( $content->marc );
 847                 }
 848         }
 849
 850         my $mods = $u->finish_mods_batch();
 851         $mods->doc_id($mrid);
 852         $request->finish();
 853
 854         $client->respond_complete($mods);
 855
 856         my $mods_string = JSON->perl2JSON($mods->decast);
 857
 858         $metarecord->mods($mods_string);
 859
 860         my $req = $session->request(
 861                         "open-ils.storage.direct.metabib.metarecord.update",
 862                         $metarecord );
 863
 864
 865         $req->gather(1);
 866
 867         $session->finish();
 868         $session->disconnect();
 869
 870         return undef;
 871
 872 }
 873
 874
 875
 876 # converts a mr id into a list of record ids
 877
 878 __PACKAGE__->register_method(
 879         method  => "biblio_mrid_to_record_ids",
 880         api_name        => "open-ils.search.biblio.metarecord_to_records",
 881 );
 882
 883 __PACKAGE__->register_method(
 884         method  => "biblio_mrid_to_record_ids",
 885         api_name        => "open-ils.search.biblio.metarecord_to_records.staff",
 886 );
 887
 888 sub biblio_mrid_to_record_ids {
 889         my( $self, $client, $mrid, $format ) = @_;
 890
 891         throw OpenSRF::EX::InvalidArg
 892                 ("search.biblio.metarecord_to_record_ids requires mr id")
 893                         unless defined( $mrid );
 894
 895         warn "Searching for record for MR $mrid and format $format\n";
 896
 897         my $method = "open-ils.storage.ordered.metabib.metarecord.records.atomic";
 898         if($self and $self->api_name =~ /staff/) { $method =~ s/atomic/staff\.atomic/; }
 899         warn "Performing record retrieval with method $method\n";
 900
 901
 902         my $mrmaps = OpenILS::Application::AppUtils->simple_scalar_request(
 903                         "open-ils.storage", $method, $mrid, $format );
 904
 905         use Data::Dumper;
 906         warn Dumper $mrmaps;
 907
 908         my $size = @$mrmaps;
 909
 910         return { count => $size, ids => $mrmaps };
 911
 912 }
 913
 914
 915 __PACKAGE__->register_method(
 916         method  => "biblio_record_to_marc_html",
 917         api_name        => "open-ils.search.biblio.record.html" );
 918
 919 my $parser              = XML::LibXML->new();
 920 my $xslt                        = XML::LibXSLT->new();
 921 my $marc_sheet;
 922
 923 my $settings_client = OpenSRF::Utils::SettingsClient->new();
 924 sub biblio_record_to_marc_html {
 925         my( $self, $client, $recordid ) = @_;
 926
 927         if( !$marc_sheet ) {
 928                 my $dir = $settings_client->config_value( "dirs", "xsl" );
 929                 my $xsl = $settings_client->config_value(
 930                         "apps", "open-ils.search", "app_settings", "marc_html_xsl" );
 931
 932                 $xsl = $parser->parse_file("$dir/$xsl");
 933                 $marc_sheet = $xslt->parse_stylesheet( $xsl );
 934         }
 935
 936
 937         my $record = $apputils->simple_scalar_request(
 938                 "open-ils.storage",
 939                 "open-ils.storage.direct.biblio.record_entry.retrieve",
 940                 $recordid );
 941
 942         my $xmldoc = $parser->parse_string($record->marc);
 943         my $html = $marc_sheet->transform($xmldoc);
 944         $html = $html->toString();
 945         return $html;
 946
 947 }
 948
 949
 950
 951 __PACKAGE__->register_method(
 952         method  => "retrieve_all_copy_locations",
 953         api_name        => "open-ils.search.config.copy_location.retrieve.all" );
 954
 955 my $shelving_locations;
 956 sub retrieve_all_copy_locations {
 957         my( $self, $client ) = @_;
 958         if(!$shelving_locations) {
 959                 $shelving_locations = $apputils->simple_scalar_request(
 960                         "open-ils.storage",
 961                         "open-ils.storage.direct.asset.copy_location.retrieve.all.atomic");
 962         }
 963         return $shelving_locations;
 964 }
 965
 966
 967
 968 __PACKAGE__->register_method(
 969         method  => "retrieve_all_copy_statuses",
 970         api_name        => "open-ils.search.config.copy_status.retrieve.all" );
 971
 972 my $copy_statuses;
 973 sub retrieve_all_copy_statuses {
 974         my( $self, $client ) = @_;
 975         if(!$copy_statuses) {
 976                 $copy_statuses = $apputils->simple_scalar_request(
 977                         "open-ils.storage",
 978                         "open-ils.storage.direct.config.copy_status.retrieve.all.atomic" );
 979         }
 980         return $copy_statuses;
 981 }
 982
 983
 984 __PACKAGE__->register_method(
 985         method  => "copy_counts_per_org",
 986         api_name        => "open-ils.search.biblio.copy_counts.retrieve");
 987
 988 __PACKAGE__->register_method(
 989         method  => "copy_counts_per_org",
 990         api_name        => "open-ils.search.biblio.copy_counts.retrieve.staff");
 991
 992 sub copy_counts_per_org {
 993         my( $self, $client, $record_id ) = @_;
 994
 995         warn "Retreiveing copy copy counts for record $record_id and method " . $self->api_name . "\n";
 996
 997         my $method = "open-ils.storage.biblio.record_entry.global_copy_count.atomic";
 998         if($self->api_name =~ /staff/) { $method =~ s/atomic/staff\.atomic/; }
 999
1000         my $counts = $apputils->simple_scalar_request(
1001                 "open-ils.storage", $method, $record_id );
1002
1003         $counts = [ sort {$a->[0] <=> $b->[0]} @$counts ];
1004         return $counts;
1005 }
1006
1007
1008 __PACKAGE__->register_method(
1009         method          => "copy_count_summary",
1010         api_name        => "open-ils.search.biblio.copy_counts.summary.retrieve",
1011         notes           => <<"  NOTES");
1012         returns an array of these:
1013                 [ org_id, callnumber_label, <status1_count>, <status2_cout>,...]
1014                 where statusx is a copy status name.  the statuses are sorted
1015                 by id.
1016         NOTES
1017
1018 sub copy_count_summary {
1019         my( $self, $client, $rid ) = @_;
1020         my $method = "open-ils.storage.biblio.record_entry.status_copy_count.atomic";
1021         return $apputils->simple_scalar_request( "open-ils.storage", $method, $rid );
1022 }
1023
1024
1025
1026
1027
1028
1029
1030
1031 1;