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.direct.biblio.record_entry.retrieve";
  35         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
  36         my $request = $session->request( $name, $recordid );
  37         $request->wait_complete;
  38         my $response = $request->recv();
  39         warn "got response from storage in retrieve for $recordid\n";
  40
  41         if(!$response) {
  42                 throw OpenSRF::EX::ERROR ("No record in database with id $recordid");
  43         }
  44
  45         if( $response->isa("OpenSRF::EX")) {
  46                 throw $response ($response->stringify);
  47         }
  48
  49         warn "grabbing content in retrieve\n";
  50         my $marcxml = $response->content;
  51
  52         if(!$marcxml) {
  53                 throw OpenSRF::EX::ERROR
  54                         ("No record in database with id $recordid");
  55         }
  56
  57         $request->finish();
  58         $session->disconnect();
  59         $session->kill_me();
  60
  61         warn "turning into nodeset\n";
  62         my $nodes = OpenILS::Utils::FlatXML->new()->xml_to_nodeset( $marcxml->marc );
  63         warn "turning nodeset into tree\n";
  64         my $tree = $utils->nodeset2tree( $nodes->nodeset );
  65
  66         $tree->owner_doc( $marcxml->id() );
  67
  68         warn "returning tree\n";
  69         #use Data::Dumper;
  70         #warn Dumper $tree;
  71
  72         return $tree;
  73 }
  74
  75 __PACKAGE__->register_method(
  76         method  => "biblio_record_tree_commit",
  77         api_name        => "open-ils.cat.biblio.record.tree.commit",
  78         argc            => 3, #(session_id, biblio_tree )
  79         note            => "Walks the tree and commits any changed nodes " .
  80                                         "adds any new nodes, and deletes any deleted nodes",
  81 );
  82
  83 sub biblio_record_tree_commit {
  84
  85         my( $self, $client, $user_session,  $tree ) = @_;
  86         new Fieldmapper::biblio::record_node ($tree);
  87
  88         use Data::Dumper;
  89
  90         throw OpenSRF::EX::InvalidArg
  91                 ("Not enough args to to open-ils.cat.biblio.record.tree.commit")
  92                 unless ( $user_session and $client and $tree );
  93
  94         my $user_obj =
  95                 OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
  96
  97         # capture the doc id
  98         my $docid = $tree->owner_doc();
  99         my $session = OpenILS::Application::AppUtils->start_db_session();
 100
 101         warn "Retrieving biblio record from storage for update\n";
 102
 103         my $req1 = $session->request('open-ils.storage',
 104                         "open-ils.storage.direct.biblio.record_entry.batch.retrieve", $docid );
 105         if(UNIVERSAL::usa($req1,"Error")) { throw $req1 ($req1->stringify);}
 106         my $biblio = $req1->content;
 107
 108
 109         # turn the tree into a nodeset
 110         my $nodeset = $utils->tree2nodeset($tree);
 111         $nodeset = $utils->clean_nodeset( $nodeset );
 112
 113         if(!defined($docid)) { # be sure
 114                 for my $node (@$nodeset) {
 115                         $docid = $node->owner_doc();
 116                         last if defined($docid);
 117                 }
 118         }
 119
 120         # turn the nodeset into a doc
 121         my $marcxml = OpenILS::Utils::FlatXML->new()->nodeset_to_xml( $nodeset );
 122
 123         #my $biblio =  Fieldmapper::biblio::record_marc->new();
 124         #$biblio->id( $docid );
 125
 126         $biblio->marc( $marcxml->toString() );
 127
 128         warn "Starting db session\n";
 129
 130         my $x = _update_record_metadata( $session, { user => $user_obj, docid => $docid } );
 131         OpenILS::Application::AppUtils->rollback_db_session($session) unless $x;
 132
 133         warn "Sending updated doc $docid to db\n";
 134         my $req = $session->request( "open-ils.storage.direct.biblio.record_entry.update", $biblio );
 135
 136         $req->wait_complete;
 137         my $status = $req->recv();
 138         if( !$status || $status->isa("Error") || ! $status->content) {
 139                 OpenILS::Application::AppUtils->rollback_db_session($session);
 140                 if($status->isa("Error")) { throw $status ($status); }
 141                 throw OpenSRF::EX::ERROR ("Error updating biblio record");
 142         }
 143         $req->finish();
 144
 145         # Send the doc to the wormer for wormizing
 146         warn "Starting worm session\n";
 147
 148         my $success = 0;
 149         my $wresp;
 150
 151         my $wreq = $session->request( "open-ils.worm.wormize", $docid );
 152         warn "Calling worm receive\n";
 153
 154         $wreq->wait_complete;
 155         $wresp = $wreq->recv();
 156
 157         if( ref($wresp) &&
 158                         UNIVERSAL::can($wresp,"content") and $wresp->content ) {
 159                 $success = 1;
 160         }
 161
 162         $wreq->finish();
 163
 164         if( !$success ) {
 165
 166                 warn "wormizing failed, rolling back\n";
 167                 if($wresp and $wresp->isa("Error") ) {
 168                         OpenILS::Application::AppUtils->rollback_db_session($session);
 169                         throw $wresp ($wresp->stringify);
 170                 }
 171
 172                 OpenILS::Application::AppUtils->rollback_db_session($session);
 173                 throw OpenSRF::EX::ERROR ("Wormizing Failed for $docid" );
 174         }
 175
 176         OpenILS::Application::AppUtils->commit_db_session( $session );
 177
 178         $nodeset = OpenILS::Utils::FlatXML->new()->xmldoc_to_nodeset($marcxml);
 179         $tree = $utils->nodeset2tree($nodeset->nodeset);
 180         $tree->owner_doc($docid);
 181
 182         $client->respond_complete($tree);
 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.direct.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         $request->finish;
 233         $session->disconnect();
 234         $session->finish();
 235
 236         return $results;
 237
 238 }
 239
 240 # gets the username
 241 sub _get_userid_by_id {
 242
 243         my @ids = @_;
 244         my @users;
 245
 246         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
 247         my $request = $session->request(
 248                 "open-ils.storage.direct.actor.user.batch.retrieve.atomic", @ids );
 249
 250         $request->wait_complete;
 251         my $response = $request->recv();
 252         if(!$request->complete) { return undef; }
 253
 254         if($response->isa("Error")){
 255                 throw $response ($response);
 256         }
 257
 258         for my $u (@{$response->content}) {
 259                 next unless ref($u);
 260                 push @users, $u->usrname;
 261         }
 262
 263         $request->finish;
 264         $session->disconnect;
 265         $session->kill_me();
 266
 267         return @users;
 268 }
 269
 270 # open-ils.storage.direct.actor.user.search.usrid
 271
 272 sub _get_id_by_userid {
 273
 274         my @users = @_;
 275         my @ids;
 276
 277         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
 278         my $request = $session->request(
 279                 "open-ils.storage.direct.actor.user.search.usrid", @users );
 280
 281         $request->wait_complete;
 282         my $response = $request->recv();
 283         if(!$request->complete) {
 284                 throw OpenSRF::EX::ERROR ("no response from storage on user retrieve");
 285         }
 286
 287         if(UNIVERSAL::isa( $response, "Error")){
 288                 throw $response ($response);
 289         }
 290
 291         for my $u (@{$response->content}) {
 292                 next unless ref($u);
 293                 push @ids, $u->id();
 294         }
 295
 296         $request->finish;
 297         $session->disconnect;
 298         $session->kill_me();
 299
 300         return @ids;
 301 }
 302
 303
 304 # commits metadata objects to the db
 305 sub _update_record_metadata {
 306
 307         my ($session, @docs ) = @_;
 308
 309         for my $doc (@docs) {
 310
 311                 my $user_obj = $doc->{user};
 312                 my $docid = $doc->{docid};
 313
 314                 warn "Updating metata for doc $docid\n";
 315
 316                 # ----------------------------------------
 317                 # grab the meta information  and update it
 318                 my $user_session = OpenSRF::AppSession->create("open-ils.storage");
 319                 my $user_request = $user_session->request(
 320                         "open-ils.storage.direct.biblio.record_entry.retrieve", $docid );
 321                 $user_request->wait_complete;
 322                 my $meta = $user_request->recv();
 323
 324                 if(!$meta) {
 325                         throw OpenSRF::EX::ERROR ("No meta info returned for biblio $docid");
 326                 }
 327                 if($meta->isa("Error")) {
 328                         throw $meta ($meta->stringify);
 329                 }
 330
 331                 $meta = $meta->content;
 332                 my ($id) = _get_id_by_userid($user_obj->usrid);
 333                 warn "got $id from _get_id_by_userid\n";
 334                 $meta->editor($id);
 335
 336                 $user_request->finish;
 337                 $user_session->disconnect;
 338                 $user_session->kill_me;
 339                 # -------------------------------------
 340
 341                 warn "Grabbed the record, updating and moving on\n";
 342
 343                 my $request = $session->request(
 344                         "open-ils.storage.direct.biblio.record_entry.update", $meta );
 345
 346                 my $response = $request->recv();
 347                 if(!$response) {
 348                         throw OpenSRF::EX::ERROR
 349                                 ("Error commit record metadata for " . $meta->id);
 350                 }
 351
 352                 if($response->isa("Error")){
 353                         throw $response ($response->stringify);
 354                 }
 355
 356                 $request->finish;
 357         }
 358
 359         warn "committing metarecord update\n";
 360
 361         return 1;
 362 }
 363
 364
 365
 366
 367 __PACKAGE__->register_method(
 368         method  => "retrieve_copies",
 369         api_name        => "open-ils.cat.asset.copy_tree.retrieve",
 370         argc            => 2,  #(user_session, record_id)
 371         note            => <<TEXT
 372         Returns the copies for a given bib record and for the users home library
 373 TEXT
 374 );
 375
 376 sub retrieve_copies {
 377
 378         my( $self, $client, $user_session, $docid, $home_ou ) = @_;
 379
 380         $docid = "$docid";
 381
 382         #my $results = [];
 383
 384         if(!$home_ou) {
 385                 my $user_obj =
 386                         OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
 387                         $home_ou = $user_obj->home_ou;
 388         }
 389
 390         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
 391
 392         # ------------------------------------------------------
 393         # grab the short name of the library location
 394         my $request = $session->request(
 395                         "open-ils.storage.direct.actor.org_unit.retrieve", $home_ou );
 396
 397         my $org_unit = $request->recv();
 398         if(!$org_unit) {
 399                 throw OpenSRF::EX::ERROR
 400                         ("No response from storage for org unit search");
 401         }
 402         if($org_unit->isa("Error")) { throw $org_unit ($org_unit->stringify);}
 403         my $location = $org_unit->content->shortname;
 404         $request->finish();
 405         # ------------------------------------------------------
 406
 407
 408         # ------------------------------------------------------
 409         # grab all the volumes for the given record and location
 410         my $search_hash = { record => $docid, owning_lib => $location };
 411
 412
 413
 414         $request = $session->request(
 415                         "open-ils.storage.direct.asset.call_number.search", $search_hash );
 416
 417         my $volume;
 418         my @volume_ids;
 419
 420         while( $volume = $request->recv() ) {
 421
 422                 if($volume->isa("Error")) {
 423                         throw $volume ($volume->stringify);}
 424
 425                 $volume = $volume->content;
 426
 427                 warn "Grabbing copies for volume: " . $volume->id . "\n";
 428                 my $copies =
 429                         OpenILS::Application::AppUtils->simple_scalar_request( "open-ils.storage",
 430                                 "open-ils.storage.direct.asset.copy.search.call_number", $volume->id );
 431
 432                 $volume->copies($copies);
 433
 434                 $client->respond( $volume );
 435
 436                 #push @$results, $volume;
 437
 438         }
 439
 440         $request->finish();
 441         $session->finish();
 442         $session->disconnect();
 443         $session->kill_me();
 444
 445         return undef;
 446         #return $results;
 447
 448 }
 449
 450
 451
 452
 453 __PACKAGE__->register_method(
 454         method  => "retrieve_copies_global",
 455         api_name        => "open-ils.cat.asset.copy_tree.global.retrieve",
 456         argc            => 2,  #(user_session, record_id)
 457         note            => <<TEXT
 458         Returns all volumes and attached copies for a given bib record
 459 TEXT
 460 );
 461
 462 sub retrieve_copies_global {
 463
 464         my( $self, $client, $user_session, $docid ) = @_;
 465
 466         $docid = "$docid";
 467
 468         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
 469
 470         # ------------------------------------------------------
 471         # grab all the volumes for the given record and location
 472         my $request = $session->request(
 473                         "open-ils.storage.direct.asset.call_number.search.record", $docid );
 474
 475         my $volumes = $request->recv();
 476
 477
 478         if($volumes->isa("Error")) {
 479                 throw $volumes ($volumes->stringify);}
 480
 481         $volumes = $volumes->content;
 482
 483         $request->finish();
 484
 485         my $vol_hash = {};
 486
 487         my @volume_ids;
 488         for my $volume (@$volumes) {
 489                 $vol_hash->{$volume->id} = $volume;
 490         }
 491
 492         my @ii = keys %$vol_hash;
 493         warn "Searching volumes @ii\n";
 494
 495         $request = $session->request(
 496                         "open-ils.storage.direct.asset.copy.search.call_number", keys %$vol_hash );
 497
 498         while( my $copylist = $request->recv ) {
 499
 500                 if(UNIVERSAL::isa( $copylist, "Error")) {
 501                         throw $copylist ($copylist->stringify);
 502                 }
 503
 504                 warn "received copy list " . time() . "\n";
 505                 $copylist = $copylist->content;
 506
 507                 my $vol;
 508                 for my $copy (@$copylist) {
 509                         $vol = $vol_hash->{$copy->call_number} unless $vol;
 510                         $vol->copies([]) unless $vol->copies();
 511                         push @{$vol->copies}, $copy;
 512                 }
 513                 $client->respond( $vol );
 514         }
 515
 516
 517
 518         $request->finish();
 519         $session->finish();
 520         $session->disconnect();
 521         $session->kill_me();
 522
 523         return undef;
 524
 525 }
 526
 527
 528
 529
 530 __PACKAGE__->register_method(
 531         method  => "generic_edit_copies_volumes",
 532         api_name        => "open-ils.cat.asset.volume.batch.update",
 533 );
 534
 535 __PACKAGE__->register_method(
 536         method  => "generic_edit_copies_volumes",
 537         api_name        => "open-ils.cat.asset.volume.batch.delete",
 538 );
 539
 540 __PACKAGE__->register_method(
 541         method  => "generic_edit_copies_volumes",
 542         api_name        => "open-ils.cat.asset.copy.batch.update",
 543 );
 544
 545 __PACKAGE__->register_method(
 546         method  => "generic_edit_copies_volumes",
 547         api_name        => "open-ils.cat.asset.copy.batch.delete",
 548 );
 549
 550
 551 sub generic_edit_copies_volumes {
 552
 553         my( $self, $client, $user_session, $items ) = @_;
 554
 555         my $method = $self->api_name;
 556         warn "received api name $method\n";
 557         $method =~ s/open-ils\.cat/open-ils\.storage/og;
 558         warn "our method is $method\n";
 559
 560         use Data::Dumper;
 561         warn Dumper $items;
 562
 563         my $user_obj =
 564                 OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
 565
 566         warn "updating editor info\n";
 567
 568         for my $item (@$items) {
 569
 570                 next unless $item;
 571
 572                 if( $method =~ /copy/ ) {
 573                         new Fieldmapper::asset::copy($item);
 574                 } else {
 575                         new Fieldmapper::asset::call_number($item);
 576                 }
 577
 578                 $item->editor( $user_obj->id );
 579         }
 580
 581         my $session = OpenILS::Application::AppUtils->start_db_session;
 582         my $request = $session->request( $method, @$items );
 583
 584         my $result = $request->recv();
 585
 586         if(!$request->complete) {
 587                 OpenILS::Application::AppUtils->rollback_db_session($session);
 588                 throw OpenSRF::EX::ERROR
 589                         ("No response from storage on $method");
 590         }
 591
 592         if(UNIVERSAL::isa($result, "Error")) {
 593                 OpenILS::Application::AppUtils->rollback_db_session($session);
 594                 throw $result ($result->stringify);
 595         }
 596
 597         OpenILS::Application::AppUtils->commit_db_session($session);
 598
 599         warn "looks like we succeeded\n";
 600         return $result->content;
 601 }
 602
 603
 604 __PACKAGE__->register_method(
 605         method  => "volume_tree_add",
 606         api_name        => "open-ils.cat.asset.volume.tree.batch.add",
 607 );
 608
 609 sub volume_tree_add {
 610
 611         my( $self, $client, $user_session, $volumes ) = @_;
 612         return undef unless $volumes;
 613
 614         use Data::Dumper;
 615         warn "Volumes:\n";
 616         warn Dumper $volumes;
 617
 618         my $user_obj =
 619                 OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
 620
 621         warn "volume_tree_add creating new db session\n";
 622
 623         my $session = OpenILS::Application::AppUtils->start_db_session;
 624
 625         for my $volume (@$volumes) {
 626
 627                 new Fieldmapper::asset::call_number($volume);
 628
 629                 warn "Looping on volumes\n";
 630
 631
 632
 633                 my $new_copy_list = $volume->copies;
 634                 my $id;
 635
 636                 warn "Searching for volume with ".$volume->owning_lib . " " .
 637                         $volume->label . " " . $volume->record . "\n";
 638
 639                 my $cn_req = $session->request(
 640                                 'open-ils.storage.direct.asset.call_number.search' =>
 641                       {       owning_lib      => $volume->owning_lib,
 642                               label           => $volume->label,
 643                               record          => $volume->record,
 644                                 });
 645
 646                 $cn_req->wait_complete;
 647                 my $cn = $cn_req->recv();
 648
 649                 if(!$cn_req->complete) {
 650                         throw OpenSRF::EX::ERROR ("Error searching volumes on storage");
 651                 }
 652
 653                 $cn_req->finish();
 654
 655                 if($cn) {
 656
 657                         if(UNIVERSAL::isa($cn,"Error")) {
 658                                 throw $cn ($cn->stringify);
 659                         }
 660
 661                         $volume = $cn->content;
 662                         $id = $volume->id;
 663                         $volume->editor( $user_obj->id );
 664
 665                 } else {
 666
 667                         $volume->creator( $user_obj->id );
 668                         $volume->editor( $user_obj->id );
 669
 670                         warn "Attempting to create a new volume:\n";
 671
 672                         warn Dumper $volume;
 673
 674                         my $request = $session->request(
 675                                 "open-ils.storage.direct.asset.call_number.create", $volume );
 676
 677                         warn "0\n";
 678                         my $response = $request->recv();
 679
 680                         warn "1\n";
 681                         if(!$request->complete) {
 682                                 OpenILS::Application::AppUtils->rollback_db_session($session);
 683                                 throw OpenSRF::EX::ERROR
 684                                         ("No response from storage on call_number.create");
 685                         }
 686
 687                         warn "2\n";
 688                         if(UNIVERSAL::isa($response, "Error")) {
 689                                 OpenILS::Application::AppUtils->rollback_db_session($session);
 690                                 throw $response ($response->stringify);
 691                         }
 692
 693                         $id = $response->content;
 694
 695                         warn "3\n";
 696                         if( $id == 0 ) {
 697                                 OpenILS::Application::AppUtils->rollback_db_session($session);
 698                                 throw OpenSRF::EX::ERROR (" * -> Error creating new volume");
 699                         }
 700
 701                         $request->finish();
 702
 703                         warn "received new volume id: $id\n";
 704
 705                 }
 706
 707
 708                 for my $copy (@{$new_copy_list}) {
 709
 710                         new Fieldmapper::asset::copy($copy);
 711
 712                         warn "adding a copy for volume $id\n";
 713
 714                         $copy->call_number($id);
 715                         $copy->creator( $user_obj->id );
 716                         $copy->editor( $user_obj->id );
 717
 718                         warn Dumper $copy;
 719
 720                         my $req = $session->request(
 721                                         "open-ils.storage.direct.asset.copy.create", $copy );
 722                         my $resp = $req->recv();
 723
 724                         if(!$resp || ! ref($resp) ) {
 725                                 OpenILS::Application::AppUtils->rollback_db_session($session);
 726                                 throw OpenSRF::EX::ERROR
 727                                         ("No response from storage on call_number.create");
 728                         }
 729
 730                         if(UNIVERSAL::isa($resp, "Error")) {
 731                                 OpenILS::Application::AppUtils->rollback_db_session($session);
 732                                 throw $resp ($resp->stringify);
 733                         }
 734
 735                         my $cid = $resp->content;
 736
 737                         if(!$cid) {
 738                                 OpenILS::Application::AppUtils->rollback_db_session($session);
 739                                 throw OpenSRF::EX::ERROR ("Error adding copy to volume $id" );
 740                         }
 741
 742                         warn "got new copy id $cid\n";
 743
 744                         $req->finish();
 745                 }
 746
 747                 warn "completed adding copies for $id\n";
 748
 749
 750         }
 751
 752         warn "committing volume tree add db session\n";
 753         OpenILS::Application::AppUtils->commit_db_session($session);
 754
 755         return scalar(@$volumes);
 756
 757 }
 758
 759
 760
 761 __PACKAGE__->register_method(
 762         method  => "volume_tree_delete",
 763         api_name        => "open-ils.cat.asset.volume.tree.batch.delete",
 764 );
 765
 766 sub volume_tree_delete {
 767
 768
 769         my( $self, $client, $user_session, $volumes ) = @_;
 770         return undef unless $volumes;
 771
 772         my $user_obj =
 773                 OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
 774
 775         my $session = OpenILS::Application::AppUtils->start_db_session;
 776
 777         for my $volume (@$volumes) {
 778
 779                 $volume->editor($user_obj->id);
 780
 781                 new Fieldmapper::asset::call_number($volume);
 782
 783                 for my $copy (@{$volume->copies}) {
 784
 785                         new Fieldmapper::asset::copy($copy);
 786
 787                         $copy->editor( $user_obj->id );
 788
 789                         warn "Deleting copy " . $copy->id . " from db\n";
 790
 791                         my $req = $session->request(
 792                                         "open-ils.storage.direct.asset.copy.delete", $copy );
 793
 794                         my $resp = $req->recv();
 795
 796                         if( !$req->complete ) {
 797                                 OpenILS::Application::AppUtils->rollback_db_session($session);
 798                                 throw OpenSRF::EX::ERROR (
 799                                                 "No response from storage on copy delete");
 800                         }
 801
 802                         if(UNIVERSAL::isa($resp, "Error")) {
 803                                 OpenILS::Application::AppUtils->rollback_db_session($session);
 804                                 throw $resp ($resp->stringify);
 805                         }
 806
 807                         $req->finish();
 808                 }
 809
 810                 warn "Deleting volume " . $volume->id . " from database\n";
 811
 812                 my $vol_req = $session->request(
 813                                 "open-ils.storage.direct.asset.call_number.delete", $volume );
 814                 my $vol_resp = $vol_req;
 815
 816                 if(!$vol_req->complete) {
 817                         OpenILS::Application::AppUtils->rollback_db_session($session);
 818                                 throw OpenSRF::EX::ERROR
 819                                         ("No response from storage on volume delete");
 820                 }
 821
 822                 if( $vol_resp and UNIVERSAL::isa($vol_resp, "Error")) {
 823                         OpenILS::Application::AppUtils->rollback_db_session($session);
 824                         throw $vol_resp ($vol_resp->stringify);
 825                 }
 826
 827                 $vol_req->finish();
 828
 829         }
 830
 831         warn "committing delete volume tree add db session\n";
 832
 833         OpenILS::Application::AppUtils->commit_db_session($session);
 834
 835         return scalar(@$volumes);
 836
 837 }
 838
 839
 840
 841
 842
 843 1;