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 use XML::LibXML;
  12 use Data::Dumper;
  13 use OpenILS::Utils::FlatXML;
  14 use OpenILS::Perm;
  15
  16 my $apputils = "OpenILS::Application::AppUtils";
  17
  18 my $utils = "OpenILS::Application::Cat::Utils";
  19
  20
  21 __PACKAGE__->register_method(
  22         method  => "biblio_record_tree_import",
  23         api_name        => "open-ils.cat.biblio.record.tree.import",
  24         notes           => <<"  NOTES");
  25         Takes a record tree and imports the record into the database.  In this
  26         case, the record tree is assumed to be a complete record (i.e. valid
  27         MARC.  The title control number is taken from (whichever comes first)
  28         tags 001, 020, 022, 010, 035 and whichever does not already exist
  29         in the database.
  30         user_session must have IMPORT_MARC permissions
  31         NOTES
  32
  33
  34 sub biblio_record_tree_import {
  35         my( $self, $client, $user_session, $tree) = @_;
  36         my $user_obj = $apputils->check_user_session($user_session);
  37
  38         if($apputils->check_user_perms(
  39                         $user_obj->id, $user_obj->home_ou, "IMPORT_MARC")) {
  40                 return OpenILS::Perm->new("IMPORT_MARC");
  41         }
  42
  43         warn "importing new record " . Dumper($tree) . "\n";
  44
  45         my $nodeset = $utils->tree2nodeset($tree);
  46         warn "turned into nodeset " . Dumper($nodeset) . "\n";
  47
  48         # copy the doc so that we can mangle the namespace.
  49         my $marcxml = OpenILS::Utils::FlatXML->new()->nodeset_to_xml($nodeset);
  50         my $copy_marcxml = XML::LibXML->new->parse_string($marcxml->toString);
  51
  52         $marcxml->documentElement->setNamespace( "http://www.loc.gov/MARC21/slim", "marc", 1 );
  53         my $tcn;
  54
  55
  56         warn "Starting db session in import\n";
  57         my $session = $apputils->start_db_session();
  58         my $source = 2; # system local source
  59
  60         my $xpath = '//controlfield[@tag="001"]';
  61         $tcn = $marcxml->documentElement->findvalue($xpath);
  62         if(_tcn_exists($session, $tcn)) {$tcn = undef;}
  63         my $tcn_source = "External";
  64
  65
  66         if(!$tcn) {
  67                 $xpath = '//datafield[@tag="020"]';
  68                 $tcn = $marcxml->documentElement->findvalue($xpath);
  69                 $tcn_source = "ISBN";
  70                 if(_tcn_exists($session, $tcn)) {$tcn = undef;}
  71         }
  72
  73         if(!$tcn) {
  74                 $xpath = '//datafield[@tag="022"]';
  75                 $tcn = $marcxml->documentElement->findvalue($xpath);
  76                 $tcn_source = "ISSN";
  77                 if(_tcn_exists($session, $tcn)) {$tcn = undef;}
  78         }
  79
  80         if(!$tcn) {
  81                 $xpath = '//datafield[@tag="010"]';
  82                 $tcn = $marcxml->documentElement->findvalue($xpath);
  83                 $tcn_source = "LCCN";
  84                 if(_tcn_exists($session, $tcn)) {$tcn = undef;}
  85         }
  86
  87         if(!$tcn) {
  88                 $xpath = '//datafield[@tag="035"]';
  89                 $tcn = $marcxml->documentElement->findvalue($xpath);
  90                 $tcn_source = "System";
  91                 if(_tcn_exists($session, $tcn)) {$tcn = undef;}
  92         }
  93
  94         $tcn =~ s/^\s+//g;
  95         $tcn =~ s/\s+$//g;
  96
  97         warn "Record import with tcn: $tcn and source $tcn_source\n";
  98
  99         my $record = Fieldmapper::biblio::record_entry->new;
 100
 101         $record->source($source);
 102         $record->tcn_source($tcn_source);
 103         $record->tcn_value($tcn);
 104         $record->creator($user_obj->id);
 105         $record->editor($user_obj->id);
 106         $record->marc($copy_marcxml->toString);
 107
 108
 109         my $req = $session->request(
 110                 "open-ils.storage.direct.biblio.record_entry.create", $record );
 111
 112         my $id = $req->gather(1);
 113
 114         if(!$id) { throw OpenSRF::EX::ERROR ("Unable to create new record_entry from import"); }
 115         warn "received id: $id from record_entry create\n";
 116
 117         $apputils->commit_db_session($session);
 118
 119         $session = OpenSRF::AppSession->create("open-ils.storage");
 120
 121         my $wreq = $session->request("open-ils.worm.wormize", $id)->gather(1);
 122         warn "Done worming record $id\n";
 123
 124         if(!$wreq) { throw OpenSRF::EX::ERROR ("Unable to wormize imported record"); }
 125
 126         return $self->biblio_record_tree_retrieve($client, $id);
 127
 128 }
 129
 130 sub _tcn_exists {
 131         my $session = shift;
 132         my $tcn = shift;
 133
 134         if(!$tcn) {return 0;}
 135
 136         my $req = $session->request(
 137                 "open-ils.storage.direct.biblio.record_entry.search.tcn_value.atomic",
 138                 $tcn );
 139         my $recs = $req->gather(1);
 140
 141         if($recs and $recs->[0]) {
 142                 return 1;
 143         }
 144         return 0;
 145 }
 146
 147
 148
 149 __PACKAGE__->register_method(
 150         method  => "biblio_record_tree_retrieve",
 151         api_name        => "open-ils.cat.biblio.record.tree.retrieve",
 152 );
 153
 154 sub biblio_record_tree_retrieve {
 155
 156         my( $self, $client, $recordid ) = @_;
 157
 158         my $name = "open-ils.storage.direct.biblio.record_entry.retrieve";
 159         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
 160         my $request = $session->request( $name, $recordid );
 161         my $marcxml = $request->gather(1);
 162
 163         if(!$marcxml) {
 164                 throw OpenSRF::EX::ERROR
 165                         ("No record in database with id $recordid");
 166         }
 167
 168         $session->disconnect();
 169         $session->kill_me();
 170
 171         warn "turning into nodeset\n";
 172         my $nodes = OpenILS::Utils::FlatXML->new()->xml_to_nodeset( $marcxml->marc );
 173         warn "turning nodeset into tree\n";
 174         my $tree = $utils->nodeset2tree( $nodes->nodeset );
 175
 176         $tree->owner_doc( $marcxml->id() );
 177
 178         warn "returning tree\n";
 179
 180         return $tree;
 181 }
 182
 183 __PACKAGE__->register_method(
 184         method  => "biblio_record_tree_commit",
 185         api_name        => "open-ils.cat.biblio.record.tree.commit",
 186         argc            => 3, #(session_id, biblio_tree )
 187         notes           => <<"  NOTES");
 188         Walks the tree and commits any changed nodes
 189         adds any new nodes, and deletes any deleted nodes
 190         The record to commit must already exist or this
 191         method will fail
 192         NOTES
 193
 194 sub biblio_record_tree_commit {
 195
 196         my( $self, $client, $user_session,  $tree ) = @_;
 197
 198         throw OpenSRF::EX::InvalidArg
 199                 ("Not enough args to to open-ils.cat.biblio.record.tree.commit")
 200                 unless ( $user_session and $tree );
 201
 202         my $user_obj = $apputils->check_user_session($user_session);
 203
 204         if($apputils->check_user_perms(
 205                         $user_obj->id, $user_obj->home_ou, "UPDATE_MARC")) {
 206                 return OpenILS::Perm->new("UPDATE_MARC");
 207         }
 208
 209
 210         # capture the doc id
 211         my $docid = $tree->owner_doc();
 212         my $session = OpenILS::Application::AppUtils->start_db_session();
 213
 214         warn "Retrieving biblio record from storage for update\n";
 215
 216         my $req1 = $session->request(
 217                         "open-ils.storage.direct.biblio.record_entry.batch.retrieve", $docid );
 218         my $biblio = $req1->gather(1);
 219
 220         warn "retrieved doc $docid\n";
 221
 222
 223         # turn the tree into a nodeset
 224         my $nodeset = $utils->tree2nodeset($tree);
 225         $nodeset = $utils->clean_nodeset($nodeset);
 226
 227         if(!defined($docid)) { # be sure
 228                 for my $node (@$nodeset) {
 229                         $docid = $node->owner_doc();
 230                         last if defined($docid);
 231                 }
 232         }
 233
 234         # turn the nodeset into a doc
 235         my $marcxml = OpenILS::Utils::FlatXML->new()->nodeset_to_xml( $nodeset );
 236
 237         $biblio->marc( $marcxml->toString() );
 238
 239         warn "Starting db session\n";
 240
 241         my $x = _update_record_metadata( $session, { user => $user_obj, docid => $docid } );
 242         OpenILS::Application::AppUtils->rollback_db_session($session) unless $x;
 243
 244         warn "Sending updated doc $docid to db\n";
 245         my $req = $session->request( "open-ils.storage.direct.biblio.record_entry.update", $biblio );
 246
 247         $req->wait_complete;
 248         my $status = $req->recv();
 249         if( !$status || $status->isa("Error") || ! $status->content) {
 250                 OpenILS::Application::AppUtils->rollback_db_session($session);
 251                 if($status->isa("Error")) { throw $status ($status); }
 252                 throw OpenSRF::EX::ERROR ("Error updating biblio record");
 253         }
 254         $req->finish();
 255
 256         # Send the doc to the wormer for wormizing
 257         warn "Starting worm session\n";
 258
 259         my $success = 0;
 260         my $wresp;
 261
 262         my $wreq = $session->request( "open-ils.worm.wormize", $docid );
 263
 264         try {
 265                 $wreq->gather(1);
 266
 267         } catch Error with {
 268                 my $e = shift;
 269                 warn "wormizing failed, rolling back\n";
 270                 OpenILS::Application::AppUtils->rollback_db_session($session);
 271
 272                 if($e) { throw $e ($e); }
 273                 throw OpenSRF::EX::ERROR ("Wormizing Failed for $docid" );
 274         };
 275
 276         warn "Committing db session...\n";
 277         OpenILS::Application::AppUtils->commit_db_session( $session );
 278
 279         $nodeset = OpenILS::Utils::FlatXML->new()->xmldoc_to_nodeset($marcxml);
 280         $tree = $utils->nodeset2tree($nodeset->nodeset);
 281         $tree->owner_doc($docid);
 282
 283 #       $client->respond_complete($tree);
 284
 285         warn "Done wormizing\n";
 286
 287         #use Data::Dumper;
 288         #warn "Returning tree:\n";
 289         #warn Dumper $tree;
 290
 291         return $tree;
 292
 293 }
 294
 295
 296
 297 __PACKAGE__->register_method(
 298         method  => "biblio_record_record_metadata",
 299         api_name        => "open-ils.cat.biblio.record.metadata.retrieve",
 300         argc            => 1, #(session_id, biblio_tree )
 301         notes           => "Walks the tree and commits any changed nodes " .
 302                                         "adds any new nodes, and deletes any deleted nodes",
 303 );
 304
 305 sub biblio_record_record_metadata {
 306         my( $self, $client, @ids ) = @_;
 307
 308         if(!@ids){return undef;}
 309
 310         my $session = OpenSRF::AppSession->create("open-ils.storage");
 311         my $request = $session->request(
 312                         "open-ils.storage.direct.biblio.record_entry.batch.retrieve", @ids );
 313
 314         my $results = [];
 315
 316         while( my $response = $request->recv() ) {
 317
 318                 if(!$response) {
 319                         throw OpenSRF::EX::ERROR ("No Response from Storage");
 320                 }
 321                 if($response->isa("Error")) {
 322                         throw $response ($response->stringify);
 323                 }
 324
 325                 my $record_entry = $response->content;
 326
 327                 my $creator = $record_entry->creator;
 328                 my $editor      = $record_entry->editor;
 329
 330                 ($creator, $editor) = _get_userid_by_id($creator, $editor);
 331
 332                 $record_entry->creator($creator);
 333                 $record_entry->editor($editor);
 334
 335                 push @$results, $record_entry;
 336
 337         }
 338
 339         $request->finish;
 340         $session->disconnect();
 341         $session->finish();
 342
 343         return $results;
 344
 345 }
 346
 347 # gets the username
 348 sub _get_userid_by_id {
 349
 350         my @ids = @_;
 351         my @users;
 352
 353         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
 354         my $request = $session->request(
 355                 "open-ils.storage.direct.actor.user.batch.retrieve.atomic", @ids );
 356
 357         $request->wait_complete;
 358         my $response = $request->recv();
 359         if(!$request->complete) { return undef; }
 360
 361         if($response->isa("Error")){
 362                 throw $response ($response);
 363         }
 364
 365         for my $u (@{$response->content}) {
 366                 next unless ref($u);
 367                 push @users, $u->usrname;
 368         }
 369
 370         $request->finish;
 371         $session->disconnect;
 372         $session->kill_me();
 373
 374         return @users;
 375 }
 376
 377 sub _get_id_by_userid {
 378
 379         my @users = @_;
 380         my @ids;
 381
 382         my $session = OpenSRF::AppSession->create( "open-ils.storage" );
 383         my $request = $session->request(
 384                 "open-ils.storage.direct.actor.user.search.usrname.atomic", @users );
 385
 386         $request->wait_complete;
 387         my $response = $request->recv();
 388         if(!$request->complete) {
 389                 throw OpenSRF::EX::ERROR ("no response from storage on user retrieve");
 390         }
 391
 392         if(UNIVERSAL::isa( $response, "Error")){
 393                 throw $response ($response);
 394         }
 395
 396         for my $u (@{$response->content}) {
 397                 next unless ref($u);
 398                 push @ids, $u->id();
 399         }
 400
 401         $request->finish;
 402         $session->disconnect;
 403         $session->kill_me();
 404
 405         return @ids;
 406 }
 407
 408
 409 # commits metadata objects to the db
 410 sub _update_record_metadata {
 411
 412         my ($session, @docs ) = @_;
 413
 414         for my $doc (@docs) {
 415
 416                 my $user_obj = $doc->{user};
 417                 my $docid = $doc->{docid};
 418
 419                 warn "Updating metata for doc $docid\n";
 420
 421                 my $request = $session->request(
 422                         "open-ils.storage.direct.biblio.record_entry.retrieve", $docid );
 423                 my $record = $request->gather(1);
 424
 425                 warn "retrieved record\n";
 426                 my ($id) = _get_id_by_userid($user_obj->usrname);
 427
 428                 warn "got $id from _get_id_by_userid\n";
 429                 $record->editor($id);
 430
 431                 warn "Grabbed the record, updating and moving on\n";
 432
 433                 $request = $session->request(
 434                         "open-ils.storage.direct.biblio.record_entry.update", $record );
 435                 $request->gather(1);
 436         }
 437
 438         warn "committing metarecord update\n";
 439
 440         return 1;
 441 }
 442
 443
 444
 445 __PACKAGE__->register_method(
 446         method  => "orgs_for_title",
 447         api_name        => "open-ils.cat.actor.org_unit.retrieve_by_title"
 448 );
 449
 450 sub orgs_for_title {
 451         my( $self, $client, $record_id ) = @_;
 452
 453         my $vols = $apputils->simple_scalar_request(
 454                 "open-ils.storage",
 455                 "open-ils.storage.direct.asset.call_number.search.record.atomic",
 456                 $record_id );
 457
 458         my $orgs = { map {$_->owning_lib => 1 } @$vols };
 459         return [ keys %$orgs ];
 460 }
 461
 462
 463
 464 __PACKAGE__->register_method(
 465         method  => "retrieve_copies",
 466         api_name        => "open-ils.cat.asset.copy_tree.retrieve");
 467
 468 __PACKAGE__->register_method(
 469         method  => "retrieve_copies",
 470         api_name        => "open-ils.cat.asset.copy_tree.global.retrieve");
 471
 472 # user_session may be null/undef
 473 sub retrieve_copies {
 474
 475         my( $self, $client, $user_session, $docid, @org_ids ) = @_;
 476
 477         if(ref($org_ids[0])) { @org_ids = @{$org_ids[0]}; }
 478
 479         $docid = "$docid";
 480
 481         warn " $$ retrieving copy tree for orgs @org_ids and doc $docid at " . time() . "\n";
 482
 483         # grabbing copy trees should be available for everyone..
 484         if(!@org_ids and $user_session) {
 485                 my $user_obj =
 486                         OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
 487                         @org_ids = ($user_obj->home_ou);
 488         }
 489
 490         if( $self->api_name =~ /global/ ) {
 491                 warn "performing global copy_tree search for $docid\n";
 492                 return _build_volume_list( { record => $docid } );
 493
 494         } else {
 495
 496                 my @all_vols;
 497                 for my $orgid (@org_ids) {
 498                         my $vols = _build_volume_list(
 499                                         { record => $docid, owning_lib => $orgid } );
 500                         warn "Volumes built for org $orgid\n";
 501                         push( @all_vols, @$vols );
 502                 }
 503
 504                 warn " $$ Finished copy_tree at " . time() . "\n";
 505                 return \@all_vols;
 506         }
 507
 508         return undef;
 509 }
 510
 511
 512 sub _build_volume_list {
 513         my $search_hash = shift;
 514
 515         my      $session = OpenSRF::AppSession->create( "open-ils.storage" );
 516
 517
 518         my $request = $session->request(
 519                         "open-ils.storage.direct.asset.call_number.search.atomic", $search_hash );
 520
 521         my $vols = $request->gather(1);
 522         my @volumes;
 523
 524         for my $volume (@$vols) {
 525
 526                 warn "Grabbing copies for volume: " . $volume->id . "\n";
 527                 my $creq = $session->request(
 528                         "open-ils.storage.direct.asset.copy.search.call_number.atomic", $volume->id );
 529
 530                 my $copies = $creq->gather(1);
 531
 532                 $copies = [ sort { $a->barcode cmp $b->barcode } @$copies  ];
 533
 534                 $volume->copies($copies);
 535
 536                 push( @volumes, $volume );
 537         }
 538
 539
 540         $session->disconnect();
 541         return \@volumes;
 542
 543 }
 544
 545
 546 # -----------------------------------------------------------------
 547 # Fleshed volume tree batch add/update.  This does everything a
 548 # volume tree could want, add, update, delete
 549 # -----------------------------------------------------------------
 550 __PACKAGE__->register_method(
 551         method  => "volume_tree_fleshed_update",
 552         api_name        => "open-ils.cat.asset.volume_tree.fleshed.batch.update",
 553 );
 554 sub volume_tree_fleshed_update {
 555
 556         my( $self, $client, $user_session, $volumes ) = @_;
 557         return undef unless $volumes;
 558
 559         my $user_obj = $apputils->check_user_session($user_session);
 560
 561
 562         my $session = $apputils->start_db_session();
 563         warn "Looping on volumes in fleshed volume tree update\n";
 564
 565         # cycle through the volumes provided and update/create/delete where necessary
 566         for my $volume (@$volumes) {
 567
 568                 warn "updating volume " . $volume->id . "\n";
 569
 570                 my $update_copy_list = $volume->copies;
 571
 572
 573                 if( $volume->isdeleted) {
 574                         my $status = _delete_volume($session, $volume, $user_obj);
 575                         if(!$status) {
 576                                 throw OpenSRF::EX::ERROR
 577                                         ("Volume delete failed for volume " . $volume->id);
 578                         }
 579                         if(UNIVERSAL::isa($status, "Fieldmapper::perm_ex")) { return $status; }
 580
 581                 } elsif( $volume->isnew ) {
 582
 583                         $volume->clear_id;
 584                         $volume->editor($user_obj->id);
 585                         $volume->creator($user_obj->id);
 586                         $volume = _add_volume($session, $volume, $user_obj);
 587                         use Data::Dumper;
 588                         warn Dumper $volume;
 589                         if($volume and UNIVERSAL::isa($volume, "Fieldmapper::perm_ex")) { return $volume; }
 590
 591                 } elsif( $volume->ischanged ) {
 592
 593                         $volume->editor($user_obj->id);
 594                         my $stat = _update_volume($session, $volume, $user_obj);
 595                         if($stat and UNIVERSAL::isa($stat, "Fieldmapper::perm_ex")) { return $stat; }
 596                 }
 597
 598
 599                 if( ! $volume->isdeleted ) {
 600                         for my $copy (@{$update_copy_list}) {
 601
 602                                 $copy->editor($user_obj->id);
 603                                 warn "updating copy for volume " . $volume->id . "\n";
 604
 605                                 if( $copy->isnew ) {
 606
 607                                         $copy->clear_id;
 608                                         $copy->call_number($volume->id);
 609                                         $copy->creator($user_obj->id);
 610                                         $copy = _fleshed_copy_update($session,$copy,$user_obj);
 611
 612                                 } elsif( $copy->ischanged ) {
 613                                         $copy->call_number($volume->id);
 614                                         $copy = _fleshed_copy_update($session, $copy, $user_obj);
 615
 616                                 } elsif( $copy->isdeleted ) {
 617                                         warn "Deleting copy " . $copy->id . " for volume " . $volume->id . "\n";
 618                                         my $status = _fleshed_copy_update($session, $copy, $user_obj);
 619                                         warn "Copy delete returned a status of $status\n";
 620                                 }
 621                         }
 622                 }
 623         }
 624
 625         $apputils->commit_db_session($session);
 626         return scalar(@$volumes);
 627 }
 628
 629
 630 sub _delete_volume {
 631         my( $session, $volume, $user_obj ) = @_;
 632
 633         if($apputils->check_user_perms(
 634                         $user_obj->id, $user_obj->home_ou, "DELETE_VOLUME")) {
 635                 return OpenILS::Perm->new("DELETE_VOLUME"); }
 636
 637         #$volume = _find_volume($session, $volume);
 638         warn "Deleting volume " . $volume->id . "\n";
 639
 640         my $copies = $session->request(
 641                 "open-ils.storage.direct.asset.copy.search.call_number.atomic",
 642                 $volume->id )->gather(1);
 643         if(@$copies) {
 644                 throw OpenSRF::EX::ERROR
 645                         ("Cannot remove volume with copies attached");
 646         }
 647
 648         my $req = $session->request(
 649                 "open-ils.storage.direct.asset.call_number.delete",
 650                 $volume );
 651         return $req->gather(1);
 652 }
 653
 654
 655 sub _update_volume {
 656         my($session, $volume, $user_obj) = @_;
 657         if($apputils->check_user_perms(
 658                         $user_obj->id, $user_obj->home_ou, "UPDATE_VOLUME")) {
 659                 return OpenILS::Perm->new("UPDATE_VOLUME"); }
 660
 661         my $req = $session->request(
 662                 "open-ils.storage.direct.asset.call_number.update",
 663                 $volume );
 664         my $status = $req->gather(1);
 665 }
 666
 667 sub _add_volume {
 668
 669         my($session, $volume, $user_obj) = @_;
 670
 671         if($apputils->check_user_perms(
 672                         $user_obj->id, $user_obj->home_ou, "CREATE_VOLUME")) {
 673                 warn "User does not have priveleges to create new volumes\n";
 674                 return OpenILS::Perm->new("CREATE_VOLUME");
 675         }
 676
 677         my $request = $session->request(
 678                 "open-ils.storage.direct.asset.call_number.create", $volume );
 679
 680         my $id = $request->gather(1);
 681
 682         if( $id == 0 ) {
 683                 OpenILS::Application::AppUtils->rollback_db_session($session);
 684                 throw OpenSRF::EX::ERROR (" * -> Error creating new volume");
 685         }
 686
 687         $volume->id($id);
 688         warn "received new volume id: $id\n";
 689         return $volume;
 690
 691 }
 692
 693
 694
 695
 696 __PACKAGE__->register_method(
 697         method  => "fleshed_copy_update",
 698         api_name        => "open-ils.cat.asset.copy.fleshed.batch.update",
 699 );
 700
 701 sub fleshed_copy_update {
 702         my($self, $client, $user_session, $copies) = @_;
 703
 704         my $user_obj = $apputils->check_user_session($user_session);
 705         my $session = $apputils->start_db_session();
 706
 707         for my $copy (@$copies) {
 708                 _fleshed_copy_update($session, $copy, $user_obj);
 709         }
 710
 711         $apputils->commit_db_session($session);
 712         return 1;
 713 }
 714
 715
 716
 717 sub _delete_copy {
 718         my($session, $copy, $user_obj) = @_;
 719
 720         if($apputils->check_user_perms(
 721                         $user_obj->id, $user_obj->home_ou, "DELETE_COPY")) {
 722                 return OpenILS::Perm->new("DELETE_COPY"); }
 723
 724         warn "Deleting copy " . $copy->id . "\n";
 725         my $request = $session->request(
 726                 "open-ils.storage.direct.asset.copy.delete",
 727                 $copy );
 728         return $request->gather(1);
 729 }
 730
 731 sub _create_copy {
 732         my($session, $copy, $user_obj) = @_;
 733
 734         if($apputils->check_user_perms(
 735                         $user_obj->id, $user_obj->home_ou, "CREATE_COPY")) {
 736                 return OpenILS::Perm->new("CREATE_COPY"); }
 737
 738         my $request = $session->request(
 739                 "open-ils.storage.direct.asset.copy.create",
 740                 $copy );
 741         my $id = $request->gather(1);
 742
 743         if($id < 1) {
 744                 throw OpenSRF::EX::ERROR
 745                         ("Unable to create new copy " . Dumper($copy));
 746         }
 747         $copy->id($id);
 748         warn "Created copy " . $copy->id . "\n";
 749
 750         return $copy;
 751
 752 }
 753
 754 sub _update_copy {
 755         my($session, $copy, $user_obj) = @_;
 756
 757         if($apputils->check_user_perms(
 758                         $user_obj->id, $user_obj->home_ou, "UPDATE_COPY")) {
 759                 return OpenILS::Perm->new("UPDATE_COPY"); }
 760
 761         my $request = $session->request(
 762                 "open-ils.storage.direct.asset.copy.update", $copy );
 763         my $status = $request->gather(1);
 764         warn "Updated copy " . $copy->id . "\n";
 765         return $status;
 766 }
 767
 768
 769 # -----------------------------------------------------------------
 770 # Creates/Updates/Deletes a fleshed asset.copy.
 771 # adds/deletes copy stat_cat maps where necessary
 772 # -----------------------------------------------------------------
 773 sub _fleshed_copy_update {
 774         my($session, $copy, $editor) = @_;
 775
 776         my $stat_cat_entries = $copy->stat_cat_entries;
 777         $copy->editor($editor->id);
 778
 779         # in case we're fleshed
 780         if(ref($copy->status))          {$copy->status( $copy->status->id ); }
 781         if(ref($copy->location))        {$copy->location( $copy->location->id ); }
 782         if(ref($copy->circ_lib))        {$copy->circ_lib( $copy->circ_lib->id ); }
 783
 784         warn "Updating copy " . Dumper($copy) . "\n";
 785
 786         if( $copy->isdeleted ) {
 787                 return _delete_copy($session, $copy, $editor);
 788         } elsif( $copy->isnew ) {
 789                 $copy = _create_copy($session, $copy, $editor);
 790         } elsif( $copy->ischanged ) {
 791                 _update_copy($session, $copy, $editor);
 792         }
 793
 794
 795         if(!@$stat_cat_entries) { return 1; }
 796
 797         my $stat_maps = $session->request(
 798                 "open-ils.storage.direct.asset.stat_cat_entry_copy_map.search.owning_copy.atomic",
 799                 $copy->id )->gather(1);
 800
 801         if(!$copy->isnew) { _delete_stale_maps($session, $stat_maps, $copy); }
 802
 803         # go through the stat cat update/create process
 804         for my $stat_entry (@{$stat_cat_entries}){
 805                 _copy_update_stat_cats( $session, $copy, $stat_maps, $stat_entry, $editor );
 806         }
 807
 808         return 1;
 809 }
 810
 811
 812 # -----------------------------------------------------------------
 813 # Deletes stat maps attached to this copy in the database that
 814 # are no longer attached to the current copy
 815 # -----------------------------------------------------------------
 816 sub _delete_stale_maps {
 817         my( $session, $stat_maps, $copy) = @_;
 818
 819         warn "Deleting stale stat maps for copy " . $copy->id . "\n";
 820         for my $map (@$stat_maps) {
 821         # if there is no stat cat entry on the copy who's id matches the
 822         # current map's id, remove the map from the database
 823         if(! grep { $_->id == $map->stat_cat_entry } @{$copy->stat_cat_entries} ) {
 824                 my $req = $session->request(
 825                         "open-ils.storage.direct.asset.stat_cat_entry_copy_map.delete", $map );
 826                 $req->gather(1);
 827                 }
 828         }
 829
 830         return $stat_maps;
 831 }
 832
 833
 834 # -----------------------------------------------------------------
 835 # Searches the stat maps to see if '$entry' already exists on
 836 # the given copy.  If it does not, a new stat map is created
 837 # for the given entry and copy
 838 # -----------------------------------------------------------------
 839 sub _copy_update_stat_cats {
 840         my ( $session, $copy, $stat_maps, $entry, $editor ) = @_;
 841
 842         warn "Updating stat maps for copy " . $copy->id . "\n";
 843
 844         # see if this map already exists
 845         for my $map (@$stat_maps) {
 846                 if( $map->stat_cat_entry == $entry->id ) {return;}
 847         }
 848
 849         warn "Creating new stat map for stat  " .
 850                 $entry->stat_cat . " and copy " . $copy->id . "\n";
 851
 852         # if not, create it
 853         my $new_map = Fieldmapper::asset::stat_cat_entry_copy_map->new();
 854
 855         $new_map->stat_cat( $entry->stat_cat );
 856         $new_map->stat_cat_entry( $entry->id );
 857         $new_map->owning_copy( $copy->id );
 858
 859         warn "New map is " . Dumper($new_map) . "\n";
 860
 861         my $request = $session->request(
 862                 "open-ils.storage.direct.asset.stat_cat_entry_copy_map.create",
 863                 $new_map );
 864         my $status = $request->gather(1);
 865         warn "created new map with id $status\n";
 866
 867 }
 868
 869
 870
 871
 872 1;