Open-ILS/src/perlmods/OpenILS/Application/Cat.pm

   1 use strict; use warnings;
   2 package OpenILS::Application::Cat;
   3 use OpenILS::Application::AppUtils;
   4 use OpenSRF::Application;
   5 use OpenILS::Application::Cat::Utils;
   6 use base qw/OpenSRF::Application/;
   7 use Time::HiRes qw(time);
   8 use OpenSRF::EX qw(:try);
   9 use JSON;
  10 use OpenILS::Utils::Fieldmapper;
  11
  12 my $utils = "OpenILS::Application::Cat::Utils";
  13
  14 sub _child_init {
  15         try {
  16                 OpenSRF::Application->method_lookup( "blah" );
  17         } catch Error with {
  18                 warn "Child Init Failed: " . shift() . "\n";
  19         };
  20 }
  21
  22
  23 __PACKAGE__->register_method(
  24         method  => "biblio_record_tree_retrieve",
  25         api_name        => "open-ils.cat.biblio.record.tree.retrieve",
  26         argc            => 1,
  27         note            => "Returns the tree associated with the nodeset of the given doc id"
  28 );
  29
  30 sub biblio_record_tree_retrieve {
  31
  32         my( $self, $client, $recordid ) = @_;
  33
  34         my $name = "open-ils.storage.biblio.record_marc.retrieve";
  35         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
  36         my $request = $session->request( $name, $recordid );
  37         my $response = $request->recv();
  38         warn "got response from storage in retrieve for $recordid\n";
  39
  40         if(!$response) {
  41                 throw OpenSRF::EX::ERROR ("No record in database with id $recordid");
  42         }
  43
  44         if( $response->isa("OpenSRF::EX")) {
  45                 throw $response ($response->stringify);
  46         }
  47
  48         warn "grabbing content in retrieve\n";
  49         my $marcxml = $response->content;
  50
  51         if(!$marcxml) {
  52                 throw OpenSRF::EX::ERROR
  53                         ("No record in database with id $recordid");
  54         }
  55
  56         $request->finish();
  57         $session->disconnect();
  58         $session->kill_me();
  59
  60         warn "turning into nodeset\n";
  61         my $nodes = OpenILS::Utils::FlatXML->new()->xml_to_nodeset( $marcxml->marc );
  62         warn "turning nodeset into tree\n";
  63         my $tree = $utils->nodeset2tree( $nodes->nodeset );
  64
  65         $tree->owner_doc( $marcxml->id() );
  66
  67         warn "returning tree\n";
  68
  69         return $tree;
  70 }
  71
  72 __PACKAGE__->register_method(
  73         method  => "biblio_record_tree_commit",
  74         api_name        => "open-ils.cat.biblio.record.tree.commit",
  75         argc            => 3, #(session_id, biblio_tree )
  76         note            => "Walks the tree and commits any changed nodes " .
  77                                         "adds any new nodes, and deletes any deleted nodes",
  78 );
  79
  80 sub biblio_record_tree_commit {
  81
  82         my( $self, $client, $user_session,  $tree ) = @_;
  83         new Fieldmapper::biblio::record_node ($tree);
  84
  85         use Data::Dumper;
  86
  87         throw OpenSRF::EX::InvalidArg
  88                 ("Not enough args to to open-ils.cat.biblio.record.tree.commit")
  89                 unless ( $user_session and $client and $tree );
  90
  91         my $user_obj =
  92                 OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
  93
  94         # capture the doc id
  95         my $docid = $tree->owner_doc();
  96
  97         # turn the tree into a nodeset
  98         my $nodeset = $utils->tree2nodeset($tree);
  99         $nodeset = $utils->clean_nodeset( $nodeset );
 100
 101         if(!defined($docid)) { # be sure
 102                 for my $node (@$nodeset) {
 103                         $docid = $node->owner_doc();
 104                         last if defined($docid);
 105                 }
 106         }
 107
 108         # turn the nodeset into a doc
 109         my $marcxml = OpenILS::Utils::FlatXML->new()->nodeset_to_xml( $nodeset );
 110
 111         my $biblio =  Fieldmapper::biblio::record_marc->new();
 112         $biblio->id( $docid );
 113         $biblio->marc( $marcxml->toString() );
 114
 115         warn "Starting db session\n";
 116         my $session = OpenILS::Application::AppUtils->start_db_session();
 117
 118         my $x = _update_record_metadata( $session, { user => $user_obj, docid => $docid } );
 119         OpenILS::Application::AppUtils->rollback_db_session($session) unless $x;
 120
 121         warn "Sending updated doc $docid to db\n";
 122         my $req = $session->request( "open-ils.storage.biblio.record_marc.update", $biblio );
 123
 124         my $status = $req->recv();
 125         if( !$status || $status->isa("Error") || ! $status->content) {
 126                 OpenILS::Application::AppUtils->rollback_db_session($session);
 127                 if($status->isa("Error")) { throw $status ($status); }
 128                 throw OpenSRF::EX::ERROR ("Error updating biblio record");
 129         }
 130         $req->finish();
 131
 132         OpenILS::Application::AppUtils->commit_db_session( $session );
 133
 134         $nodeset = OpenILS::Utils::FlatXML->new()->xmldoc_to_nodeset($marcxml);
 135         $tree = $utils->nodeset2tree($nodeset->nodeset);
 136         $tree->owner_doc($docid);
 137
 138         $client->respond_complete($tree);
 139
 140
 141
 142         # Send the doc to the wormer for wormizing
 143         warn "Starting worm session\n";
 144         my $wses = OpenSRF::AppSession->create("open-ils.worm");
 145
 146         my $success = 0;
 147         my $wresp;
 148         for(0..9) {
 149
 150                 my $wreq = $wses->request(
 151                                 "open-ils.worm.wormize.marc", $docid, $marcxml->toString );
 152                 warn "Calling worm receive\n";
 153                 $wresp = $wreq->recv();
 154
 155                 if( $wresp && $wresp->can("content") and $wresp->content ) {
 156                         $success = 1;
 157                         $wreq->finish();
 158                         last;
 159                 }
 160
 161                 warn "Looping in worm call\n";
 162                 $wreq->finish();
 163         }
 164
 165         if( !$success ) {
 166
 167                 warn "wormizing failed, rolling back\n";
 168                 if($wresp and $wresp->isa("Error") ) {
 169                         OpenILS::Application::AppUtils->rollback_db_session($session);
 170                         throw $wresp ($wresp->stringify);
 171                 }
 172
 173                 $wses->disconnect;
 174                 $wses->kill_me;
 175
 176                 OpenILS::Application::AppUtils->rollback_db_session($session);
 177
 178                 throw OpenSRF::EX::ERROR ("Wormizing Failed for $docid" );
 179         }
 180
 181         $wses->disconnect;
 182         $wses->kill_me;
 183
 184         warn "Done wormizing\n";
 185
 186 }
 187
 188
 189
 190 __PACKAGE__->register_method(
 191         method  => "biblio_record_record_metadata",
 192         api_name        => "open-ils.cat.biblio.record.metadata.retrieve",
 193         argc            => 1, #(session_id, biblio_tree )
 194         note            => "Walks the tree and commits any changed nodes " .
 195                                         "adds any new nodes, and deletes any deleted nodes",
 196 );
 197
 198 sub biblio_record_record_metadata {
 199         my( $self, $client, @ids ) = @_;
 200
 201         if(!@ids){return undef;}
 202
 203         my $session = OpenSRF::AppSession->create("open-ils.storage");
 204         my $request = $session->request(
 205                         "open-ils.storage.biblio.record_entry.batch.retrieve", @ids );
 206
 207         my $results = [];
 208
 209         while( my $response = $request->recv() ) {
 210
 211                 if(!$response) {
 212                         throw OpenSRF::EX::ERROR ("No Response from Storage");
 213                 }
 214                 if($response->isa("Error")) {
 215                         throw $response ($response->stringify);
 216                 }
 217
 218                 my $record_entry = $response->content;
 219
 220                 my $creator = $record_entry->creator;
 221                 my $editor      = $record_entry->editor;
 222
 223                 ($creator, $editor) = _get_userid_by_id($creator, $editor);
 224
 225                 $record_entry->creator( $creator );
 226                 $record_entry->editor( $editor );
 227
 228                 push @$results, $record_entry;
 229
 230         }
 231
 232         $session->disconnect();
 233         $session->kill_me();
 234
 235         return $results;
 236
 237 }
 238
 239 # gets the username
 240 sub _get_userid_by_id {
 241
 242         my @ids = @_;
 243         my @users;
 244
 245         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
 246         my $request = $session->request(
 247                 "open-ils.storage.actor.user.batch.retrieve.atomic", @ids );
 248
 249         my $response = $request->recv();
 250         if(!$response) { return undef; }
 251
 252         if($response->isa("Error")){
 253                 throw $response ($response);
 254         }
 255
 256         for my $u (@{$response->content}) {
 257                 next unless ref($u);
 258                 push @users, $u->usrname;
 259         }
 260
 261         $request->finish;
 262         $session->disconnect;
 263         $session->kill_me();
 264
 265         return @users;
 266 }
 267
 268 # open-ils.storage.actor.user.search.usrid
 269
 270 sub _get_id_by_userid {
 271
 272         my @users = @_;
 273         my @ids;
 274
 275         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
 276         my $request = $session->request(
 277                 "open-ils.storage.actor.user.search.usrid", @users );
 278
 279         my $response = $request->recv();
 280         if(!$response) { return undef; }
 281
 282         if($response->isa("Error")){
 283                 throw $response ($response);
 284         }
 285
 286         for my $u (@{$response->content}) {
 287                 next unless ref($u);
 288                 push @ids, $u->id();
 289         }
 290
 291         $request->finish;
 292         $session->disconnect;
 293         $session->kill_me();
 294
 295         return @ids;
 296 }
 297
 298
 299 # commits metadata objects to the db
 300 sub _update_record_metadata {
 301
 302         my ($session, @docs ) = @_;
 303
 304         for my $doc (@docs) {
 305
 306                 my $user_obj = $doc->{user};
 307                 my $docid = $doc->{docid};
 308
 309                 warn "Updating metata for doc $docid\n";
 310
 311                 # ----------------------------------------
 312                 # grab the meta information  and update it
 313                 my $user_session = OpenSRF::AppSession->create("open-ils.storage");
 314                 my $user_request = $user_session->request(
 315                         "open-ils.storage.biblio.record_entry.retrieve", $docid );
 316                 my $meta = $user_request->recv();
 317
 318                 if(!$meta) {
 319                         throw OpenSRF::EX::ERROR ("No meta info returned for biblio $docid");
 320                 }
 321                 if($meta->isa("Error")) {
 322                         throw $meta ($meta->stringify);
 323                 }
 324
 325                 $meta = $meta->content;
 326                 my ($id) = _get_id_by_userid($user_obj->usrid);
 327                 warn "got $id from _get_id_by_userid\n";
 328                 $meta->editor($id);
 329
 330                 $user_request->finish;
 331                 $user_session->disconnect;
 332                 $user_session->kill_me;
 333                 # -------------------------------------
 334
 335                 warn "Grabbed the record, updating and moving on\n";
 336
 337                 my $request = $session->request(
 338                         "open-ils.storage.biblio.record_entry.update", $meta );
 339
 340                 my $response = $request->recv();
 341                 if(!$response) {
 342                         throw OpenSRF::EX::ERROR
 343                                 ("Error commit record metadata for " . $meta->id);
 344                 }
 345
 346                 if($response->isa("Error")){
 347                         throw $response ($response->stringify);
 348                 }
 349
 350                 $request->finish;
 351         }
 352
 353         warn "committing metarecord update\n";
 354
 355         return 1;
 356 }
 357
 358
 359
 360
 361 __PACKAGE__->register_method(
 362         method  => "retrieve_copies",
 363         api_name        => "open-ils.cat.asset.copy_tree.retrieve",
 364         argc            => 2,  #(user_session, record_id)
 365         note            => <<TEXT
 366         Returns the copies for a given bib record and for the users home library
 367 TEXT
 368 );
 369
 370 sub retrieve_copies {
 371
 372         my( $self, $client, $user_session, $docid, $home_ou ) = @_;
 373
 374         $docid = "$docid";
 375
 376         #my $results = [];
 377
 378         if(!$home_ou) {
 379                 my $user_obj =
 380                         OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
 381                         $home_ou = $user_obj->home_ou;
 382         }
 383
 384         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
 385
 386         # ------------------------------------------------------
 387         # grab the short name of the library location
 388         my $request = $session->request(
 389                         "open-ils.storage.actor.org_unit.retrieve", $home_ou );
 390
 391         my $org_unit = $request->recv();
 392         if(!$org_unit) {
 393                 throw OpenSRF::EX::ERROR
 394                         ("No response from storage for org unit search");
 395         }
 396         if($org_unit->isa("Error")) { throw $org_unit ($org_unit->stringify);}
 397         my $location = $org_unit->content->shortname;
 398         $request->finish();
 399         # ------------------------------------------------------
 400
 401
 402         # ------------------------------------------------------
 403         # grab all the volumes for the given record and location
 404         my $search_hash = { record => $docid, owning_lib => $location };
 405
 406
 407
 408         $request = $session->request(
 409                         "open-ils.storage.asset.call_number.search", $search_hash );
 410
 411         my $volume;
 412         my @volume_ids;
 413
 414         while( $volume = $request->recv() ) {
 415
 416                 if($volume->isa("Error")) {
 417                         throw $volume ($volume->stringify);}
 418
 419                 $volume = $volume->content;
 420
 421                 warn "Grabbing copies for volume: " . $volume->id . "\n";
 422                 my $copies =
 423                         OpenILS::Application::AppUtils->simple_scalar_request( "open-ils.storage",
 424                                 "open-ils.storage.asset.copy.search.call_number", $volume->id );
 425
 426                 $volume->copies($copies);
 427
 428                 $client->respond( $volume );
 429
 430                 #push @$results, $volume;
 431
 432         }
 433
 434         $request->finish();
 435         $session->finish();
 436         $session->disconnect();
 437         $session->kill_me();
 438
 439         return undef;
 440         #return $results;
 441
 442 }
 443
 444
 445
 446
 447 __PACKAGE__->register_method(
 448         method  => "retrieve_copies_global",
 449         api_name        => "open-ils.cat.asset.copy_tree.global.retrieve",
 450         argc            => 2,  #(user_session, record_id)
 451         note            => <<TEXT
 452         Returns all volumes and attached copies for a given bib record
 453 TEXT
 454 );
 455
 456 sub retrieve_copies_global {
 457
 458         my( $self, $client, $user_session, $docid ) = @_;
 459
 460         $docid = "$docid";
 461
 462         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
 463
 464         # ------------------------------------------------------
 465         # grab all the volumes for the given record and location
 466         my $request = $session->request(
 467                         "open-ils.storage.asset.call_number.search.record", $docid );
 468
 469         my $volumes = $request->recv();
 470
 471
 472         if($volumes->isa("Error")) {
 473                 throw $volumes ($volumes->stringify);}
 474
 475         $volumes = $volumes->content;
 476
 477         $request->finish();
 478
 479         my $vol_hash = {};
 480
 481         my @volume_ids;
 482         for my $volume (@$volumes) {
 483                 $vol_hash->{$volume->id} = $volume;
 484         }
 485
 486         my @ii = keys %$vol_hash;
 487         warn "Searching volumes @ii\n";
 488
 489         $request = $session->request(
 490                         "open-ils.storage.asset.copy.search.call_number", keys %$vol_hash );
 491
 492         while( my $copylist = $request->recv ) {
 493
 494                 if(UNIVERSAL::isa( $copylist, "Error")) {
 495                         throw $copylist ($copylist->stringify);
 496                 }
 497
 498                 warn "received copy list " . time() . "\n";
 499                 $copylist = $copylist->content;
 500
 501                 my $vol;
 502                 for my $copy (@$copylist) {
 503                         $vol = $vol_hash->{$copy->call_number} unless $vol;
 504                         $vol->copies([]) unless $vol->copies();
 505                         push @{$vol->copies}, $copy;
 506                 }
 507                 $client->respond( $vol );
 508         }
 509
 510
 511
 512         $request->finish();
 513         $session->finish();
 514         $session->disconnect();
 515         $session->kill_me();
 516
 517         return undef;
 518
 519 }
 520
 521
 522
 523 __PACKAGE__->register_method(
 524         method  => "create_copies",
 525         api_name        => "open-ils.cat.asset.copy.batch.create",
 526         argc            => 2,  #(user_session, record_id)
 527         note            => "Adds the given copies to the database"
 528 );
 529
 530 sub create_copies {
 531         my( $self, $client, $user_session, @copies ) = @_;
 532
 533         my $user_obj =
 534                 OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
 535
 536         for my $copy (@copies) {
 537                 $copy->editor( $user_obj->id );
 538                 $copy->creator( $user_obj->id );
 539         }
 540
 541         my $result =
 542                 OpenILS::Application::AppUtils->simple_scalar_request(
 543                         "open-ils.storage", "open-ils.storage.asset.copy.batch.create", @copies );
 544
 545         return $result;
 546 }
 547
 548
 549 __PACKAGE__->register_method(
 550         method  => "edit_copies",
 551         api_name        => "open-ils.cat.asset.copy.batch.update",
 552         argc            => 2,  #(user_session, record_id)
 553         note            => "Updates the given copies",
 554 );
 555
 556
 557 sub edit_copies {
 558         my( $self, $client, $user_session, @copies ) = @_;
 559
 560         my $user_obj =
 561                 OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
 562
 563         for my $copy (@copies) {
 564                 $copy->editor( $user_obj->id );
 565         }
 566
 567         my $result =
 568                 OpenILS::Application::AppUtils->simple_scalar_request(
 569                         "open-ils.storage", "open-ils.storage.asset.copy.batch.update", @copies );
 570
 571         return $result;
 572 }
 573
 574
 575
 576 __PACKAGE__->register_method(
 577         method  => "delete_copies",
 578         api_name        => "open-ils.cat.asset.copy.batch.delete",
 579         argc            => 2,  #(user_session, record_id)
 580         note            => "Removes the given copies from the database",
 581 );
 582
 583
 584 sub delete_copies {
 585         my( $self, $client, $user_session, @copies ) = @_;
 586
 587         my $user_obj =
 588                 OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
 589
 590         for my $copy (@copies) {
 591                 $copy->editor( $user_obj->id );
 592         }
 593
 594         my $result =
 595                 OpenILS::Application::AppUtils->simple_scalar_request(
 596                         "open-ils.storage", "open-ils.storage.asset.copy.batch.update", @copies );
 597
 598         return $result;
 599 }
 600
 601 1;