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