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 OpenILS::Application::Cat::Merge;
7 use base qw/OpenSRF::Application/;
8 use Time::HiRes qw(time);
9 use OpenSRF::EX qw(:try);
11 use OpenILS::Utils::Fieldmapper;
15 use Unicode::Normalize;
17 use OpenILS::Utils::FlatXML;
18 use OpenILS::Utils::Editor;
20 use OpenSRF::Utils::SettingsClient;
21 use OpenSRF::Utils::Logger qw($logger);
23 my $apputils = "OpenILS::Application::AppUtils";
25 my $utils = "OpenILS::Application::Cat::Utils";
26 my $U = "OpenILS::Application::AppUtils";
34 my $form = shift || "";
42 $stuff =~ s/([\x{0080}-\x{fffd}])/sprintf('&#x%X;',ord($1))/sgoe;
46 __PACKAGE__->register_method(
47 method => "retrieve_marc_template",
48 api_name => "open-ils.cat.biblio.marc_template.retrieve",
50 Returns a MARC 'record tree' based on a set of pre-defined templates.
51 Templates include : book
54 sub retrieve_marc_template {
55 my( $self, $client, $type ) = @_;
57 return $marctemplates{$type} if defined($marctemplates{$type});
58 $marctemplates{$type} = _load_marc_template($type);
59 return $marctemplates{$type};
62 sub _load_marc_template {
65 if(!$conf) { $conf = OpenSRF::Utils::SettingsClient->new; }
67 my $template = $conf->config_value(
68 "apps", "open-ils.cat","app_settings", "marctemplates", $type );
69 warn "Opening template file $template\n";
71 open( F, $template ) or
72 throw OpenSRF::EX::ERROR ("Unable to open MARC template file: $template : $@");
76 my $xml = join('', @xml);
78 return XML::LibXML->new->parse_string($xml)->documentElement->toString;
83 __PACKAGE__->register_method(
84 method => "create_record_xml",
85 api_name => "open-ils.cat.biblio.record.xml.create.override",
86 signature => q/@see open-ils.cat.biblio.record.xml.create/);
88 __PACKAGE__->register_method(
89 method => "create_record_xml",
90 api_name => "open-ils.cat.biblio.record.xml.create",
92 Inserts a new biblio with the given XML
96 sub create_record_xml {
97 my( $self, $client, $login, $xml, $source ) = @_;
100 my $override = 1 if $self->api_name =~ /override/;
102 my( $user_obj, $evt ) = $U->checksesperm($login, 'CREATE_MARC');
105 $logger->activity("user ".$user_obj->id." creating new MARC record");
107 my $meth = $self->method_lookup("open-ils.cat.biblio.record.xml.import");
109 $meth = $self->method_lookup(
110 "open-ils.cat.biblio.record.xml.import.override") if $override;
112 my ($s) = $meth->run($login, $xml, 2);
119 __PACKAGE__->register_method(
120 method => "biblio_record_xml_import",
121 api_name => "open-ils.cat.biblio.record.xml.import.override",
122 signature => q/@see open-ils.cat.biblio.record.xml.import/);
124 __PACKAGE__->register_method(
125 method => "biblio_record_xml_import",
126 api_name => "open-ils.cat.biblio.record.xml.import",
127 notes => <<" NOTES");
128 Takes a marcxml record and imports the record into the database. In this
129 case, the marcxml record is assumed to be a complete record (i.e. valid
130 MARC). The title control number is taken from (whichever comes first)
131 tags 001, 039[ab], 020a, 022a, 010, 035a and whichever does not already exist
133 user_session must have IMPORT_MARC permissions
137 sub biblio_record_xml_import {
138 my( $self, $client, $authtoken, $xml, $source) = @_;
140 my ($tcn, $tcn_source);
142 my $override = 1 if $self->api_name =~ /override/;
144 my( $requestor, $evt ) = $U->checksesperm($authtoken, 'IMPORT_MARC');
147 my $session = $apputils->start_db_session();
150 my $marcxml = XML::LibXML->new->parse_string( $xml );
151 $marcxml->documentElement->setNamespace(
152 "http://www.loc.gov/MARC21/slim", "marc", 1 );
154 my $xpath = '//marc:controlfield[@tag="001"]';
155 $tcn = $marcxml->documentElement->findvalue($xpath);
156 $logger->info("biblio import located 001 (tcn) value of $tcn");
158 $xpath = '//marc:controlfield[@tag="003"]';
159 $tcn_source = $marcxml->documentElement->findvalue($xpath) || "System Local";
161 if(my $rec = _tcn_exists($session, $tcn, $tcn_source)) {
164 $tcn = find_free_tcn( $marcxml, $session );
166 # if we're overriding, try to find a different TCN to use
169 $logger->activity("tcn value $tcn already exists, attempting to override");
172 return OpenILS::Event->new(
173 'OPEN_TCN_NOT_FOUND', payload => $marcxml->toString());
178 $logger->warn("tcn value $origtcn already exists in import/create");
180 # otherwise, return event
181 return OpenILS::Event->new(
182 'TCN_EXISTS', payload => {
191 $logger->activity("user ".$requestor->id.
192 " creating new biblio entry with tcn=$tcn and tcn_source $tcn_source");
196 my $record = Fieldmapper::biblio::record_entry->new;
198 $record->source($source) if ($source);
199 $record->tcn_source($tcn_source);
200 $record->tcn_value($tcn);
201 $record->creator($requestor->id);
202 $record->editor($requestor->id);
203 $record->marc( entityize( $marcxml->documentElement->toString ) );
205 my $id = $session->request(
206 "open-ils.storage.direct.biblio.record_entry.create", $record )->gather(1);
208 return $U->DB_UPDATE_FAILED($record) unless $id;
211 $logger->info("marc create/import created new record $id");
213 $apputils->commit_db_session($session);
215 $logger->debug("Sending record off to be wormized");
217 my $stat = $U->storagereq( 'open-ils.worm.wormize.biblio', $id );
218 throw OpenSRF::EX::ERROR
219 ("Unable to wormize imported record") unless $stat;
231 my $xpath = '//marc:datafield[@tag="039"]/subfield[@code="a"]';
232 my ($tcn) = $marcxml->documentElement->findvalue($xpath) =~ /(\w+)\s*$/o;
233 $xpath = '//marc:datafield[@tag="039"]/subfield[@code="b"]';
234 my $tcn_source = $marcxml->documentElement->findvalue($xpath) || "System Local";
236 if(_tcn_exists($session, $tcn, $tcn_source)) {
244 $xpath = '//marc:datafield[@tag="020"]/subfield[@code="a"]';
245 ($tcn) = $marcxml->documentElement->findvalue($xpath) =~ /(\w+)\s*$/o;
246 $tcn_source = "ISBN";
247 if(_tcn_exists($session, $tcn, $tcn_source)) {$tcn = undef;}
251 $xpath = '//marc:datafield[@tag="022"]/subfield[@code="a"]';
252 ($tcn) = $marcxml->documentElement->findvalue($xpath) =~ /(\w+)\s*$/o;
253 $tcn_source = "ISSN";
254 if(_tcn_exists($session, $tcn, $tcn_source)) {$tcn = undef;}
258 $xpath = '//marc:datafield[@tag="010"]';
259 ($tcn) = $marcxml->documentElement->findvalue($xpath) =~ /(\w+)\s*$/o;
260 $tcn_source = "LCCN";
261 if(_tcn_exists($session, $tcn, $tcn_source)) {$tcn = undef;}
265 $xpath = '//marc:datafield[@tag="035"]/subfield[@code="a"]';
266 ($tcn) = $marcxml->documentElement->findvalue($xpath) =~ /(\w+)\s*$/o;
267 $tcn_source = "System Legacy";
268 if(_tcn_exists($session, $tcn, $tcn_source)) {$tcn = undef;}
271 $marcxml->documentElement->removeChild(
272 $marcxml->documentElement->findnodes( '//datafield[@tag="035"]' )
278 my $df = $marcxml->createElementNS( 'http://www.loc.gov/MARC21/slim', 'datafield');
279 $df->setAttribute( tag => '039' );
280 $df->setAttribute( ind1 => ' ' );
281 $df->setAttribute( ind2 => ' ' );
282 $marcxml->documentElement->appendChild( $df );
284 my $sfa = $marcxml->createElementNS( 'http://www.loc.gov/MARC21/slim', 'subfield');
285 $sfa->setAttribute( code => 'a' );
286 $sfa->appendChild( $marcxml->createTextNode( $tcn ) );
287 $df->appendChild( $sfa );
289 my $sfb = $marcxml->createElementNS( 'http://www.loc.gov/MARC21/slim', 'subfield');
290 $sfb->setAttribute( code => 'b' );
291 $sfb->appendChild( $marcxml->createTextNode( $tcn_source ) );
292 $df->appendChild( $sfb );
305 if(!$tcn) {return 0;}
307 $logger->debug("tcn_exists search for tcn $tcn and source $source");
309 my $req = $session->request(
310 "open-ils.storage.id_list.biblio.record_entry.search_where.atomic",
311 { tcn_value => $tcn, tcn_source => $source, deleted => 'f' } );
313 my $recs = $req->gather(1);
315 if($recs and $recs->[0]) {
316 $logger->debug("_tcn_exists is true for tcn : $tcn ($source)");
320 $logger->debug("_tcn_exists is false for tcn : $tcn ($source)");
326 __PACKAGE__->register_method(
327 method => "biblio_record_tree_retrieve",
328 api_name => "open-ils.cat.biblio.record.tree.retrieve",
331 sub biblio_record_tree_retrieve {
333 my( $self, $client, $recordid ) = @_;
335 my $name = "open-ils.storage.direct.biblio.record_entry.retrieve";
336 my $session = OpenSRF::AppSession->create( "open-ils.storage" );
337 my $request = $session->request( $name, $recordid );
338 my $marcxml = $request->gather(1);
341 throw OpenSRF::EX::ERROR
342 ("No record in database with id $recordid");
345 $session->disconnect();
348 warn "turning into nodeset\n";
349 my $nodes = OpenILS::Utils::FlatXML->new()->xml_to_nodeset( $marcxml->marc );
350 warn "turning nodeset into tree\n";
351 my $tree = $utils->nodeset2tree( $nodes->nodeset );
353 $tree->owner_doc( $marcxml->id() );
355 warn "returning tree\n";
360 __PACKAGE__->register_method(
361 method => "biblio_record_xml_update",
362 api_name => "open-ils.cat.biblio.record.xml.update",
363 argc => 3, #(session_id, biblio_tree )
364 notes => <<' NOTES');
365 Updates the XML of a biblio record entry
366 @param authtoken The session token for the staff updating the record
367 @param docID The record entry ID to update
368 @param xml The new MARCXML record
371 sub biblio_record_xml_update {
373 my( $self, $client, $user_session, $id, $xml ) = @_;
375 my $user_obj = $apputils->check_user_session($user_session);
377 if($apputils->check_user_perms(
378 $user_obj->id, $user_obj->home_ou, "UPDATE_MARC")) {
379 return OpenILS::Perm->new("UPDATE_MARC");
382 $logger->activity("user ".$user_obj->id." updating biblio record $id");
385 my $session = OpenILS::Application::AppUtils->start_db_session();
387 warn "Retrieving biblio record from storage for update\n";
389 my $req1 = $session->request(
390 "open-ils.storage.direct.biblio.record_entry.batch.retrieve", $id );
391 my $biblio = $req1->gather(1);
393 warn "retrieved doc $id\n";
395 my $doc = XML::LibXML->new->parse_string($xml);
396 throw OpenSRF::EX::ERROR ("Invalid XML in record update: $xml") unless $doc;
398 $biblio->marc( entityize( $doc->documentElement->toString ) );
399 $biblio->editor( $user_obj->id );
400 $biblio->edit_date( 'now' );
402 warn "Sending updated doc $id to db with xml ".$biblio->marc. "\n";
404 my $req = $session->request(
405 "open-ils.storage.direct.biblio.record_entry.update", $biblio );
408 my $status = $req->recv();
409 if( !$status || $status->isa("Error") || ! $status->content) {
410 OpenILS::Application::AppUtils->rollback_db_session($session);
411 if($status->isa("Error")) { throw $status ($status); }
412 throw OpenSRF::EX::ERROR ("Error updating biblio record");
416 # Send the doc to the wormer for wormizing
417 warn "Starting worm session\n";
422 my $wreq = $session->request( "open-ils.worm.wormize.biblio", $id );
426 $w = $wreq->gather(1);
430 warn "wormizing failed, rolling back\n";
431 OpenILS::Application::AppUtils->rollback_db_session($session);
433 if($e) { throw $e ($e); }
434 throw OpenSRF::EX::ERROR ("Wormizing Failed for $id" );
437 warn "Committing db session...\n";
438 OpenILS::Application::AppUtils->commit_db_session( $session );
440 # $client->respond_complete($tree);
442 warn "Done wormizing\n";
445 #warn "Returning tree:\n";
454 __PACKAGE__->register_method(
455 method => "biblio_record_record_metadata",
456 api_name => "open-ils.cat.biblio.record.metadata.retrieve",
457 argc => 1, #(session_id, biblio_tree )
458 notes => "Walks the tree and commits any changed nodes " .
459 "adds any new nodes, and deletes any deleted nodes",
462 sub biblio_record_record_metadata {
463 my( $self, $client, @ids ) = @_;
465 if(!@ids){return undef;}
467 my $session = OpenSRF::AppSession->create("open-ils.storage");
468 my $request = $session->request(
469 "open-ils.storage.direct.biblio.record_entry.batch.retrieve", @ids );
473 while( my $response = $request->recv() ) {
476 throw OpenSRF::EX::ERROR ("No Response from Storage");
478 if($response->isa("Error")) {
479 throw $response ($response->stringify);
482 my $record_entry = $response->content;
484 my $creator = $record_entry->creator;
485 my $editor = $record_entry->editor;
487 ($creator, $editor) = _get_userid_by_id($creator, $editor);
489 $record_entry->creator($creator);
490 $record_entry->editor($editor);
492 push @$results, $record_entry;
497 $session->disconnect();
504 __PACKAGE__->register_method(
505 method => "biblio_record_marc_cn",
506 api_name => "open-ils.cat.biblio.record.marc_cn.retrieve",
507 argc => 1, #(bib id )
510 sub biblio_record_marc_cn {
511 my( $self, $client, $id ) = @_;
513 my $session = OpenSRF::AppSession->create("open-ils.storage");
515 ->request("open-ils.storage.direct.biblio.record_entry.retrieve", $id )
519 my $doc = XML::LibXML->new->parse_string($marc);
520 $doc->documentElement->setNamespace( "http://www.loc.gov/MARC21/slim", "marc", 1 );
523 for my $tag ( qw/050 055 060 070 080 082 086 088 090 092 096 098 099/ ) {
524 my @node = $doc->findnodes("//marc:datafield[\@tag='$tag']");
526 my $cn = $x->findvalue("marc:subfield[\@code='a' or \@code='b']");
527 push @res, {$tag => $cn} if ($cn);
535 sub _get_userid_by_id {
540 my $session = OpenSRF::AppSession->create( "open-ils.storage" );
541 my $request = $session->request(
542 "open-ils.storage.direct.actor.user.batch.retrieve.atomic", @ids );
544 $request->wait_complete;
545 my $response = $request->recv();
546 if(!$request->complete) { return undef; }
548 if($response->isa("Error")){
549 throw $response ($response);
552 for my $u (@{$response->content}) {
554 push @users, $u->usrname;
558 $session->disconnect;
564 sub _get_id_by_userid {
569 my $session = OpenSRF::AppSession->create( "open-ils.storage" );
570 my $request = $session->request(
571 "open-ils.storage.direct.actor.user.search.usrname.atomic", @users );
573 $request->wait_complete;
574 my $response = $request->recv();
575 if(!$request->complete) {
576 throw OpenSRF::EX::ERROR ("no response from storage on user retrieve");
579 if(UNIVERSAL::isa( $response, "Error")){
580 throw $response ($response);
583 for my $u (@{$response->content}) {
589 $session->disconnect;
596 # commits metadata objects to the db
597 sub _update_record_metadata {
599 my ($session, @docs ) = @_;
601 for my $doc (@docs) {
603 my $user_obj = $doc->{user};
604 my $docid = $doc->{docid};
606 warn "Updating metata for doc $docid\n";
608 my $request = $session->request(
609 "open-ils.storage.direct.biblio.record_entry.retrieve", $docid );
610 my $record = $request->gather(1);
612 warn "retrieved record\n";
613 my ($id) = _get_id_by_userid($user_obj->usrname);
615 warn "got $id from _get_id_by_userid\n";
616 $record->editor($id);
618 warn "Grabbed the record, updating and moving on\n";
620 $request = $session->request(
621 "open-ils.storage.direct.biblio.record_entry.update", $record );
625 warn "committing metarecord update\n";
632 __PACKAGE__->register_method(
633 method => "orgs_for_title",
634 api_name => "open-ils.cat.actor.org_unit.retrieve_by_title"
638 my( $self, $client, $record_id ) = @_;
640 my $vols = $apputils->simple_scalar_request(
642 "open-ils.storage.direct.asset.call_number.search_where.atomic",
643 { record => $record_id, deleted => 'f' });
644 #"open-ils.storage.direct.asset.call_number.search.record.atomic",
646 my $orgs = { map {$_->owning_lib => 1 } @$vols };
647 return [ keys %$orgs ];
651 __PACKAGE__->register_method(
652 method => "retrieve_copies",
653 api_name => "open-ils.cat.asset.copy_tree.retrieve");
655 __PACKAGE__->register_method(
656 method => "retrieve_copies",
657 api_name => "open-ils.cat.asset.copy_tree.global.retrieve");
659 # user_session may be null/undef
660 sub retrieve_copies {
662 my( $self, $client, $user_session, $docid, @org_ids ) = @_;
664 if(ref($org_ids[0])) { @org_ids = @{$org_ids[0]}; }
668 warn " $$ retrieving copy tree for orgs @org_ids and doc $docid at " . time() . "\n";
670 # grabbing copy trees should be available for everyone..
671 if(!@org_ids and $user_session) {
673 OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
674 @org_ids = ($user_obj->home_ou);
677 if( $self->api_name =~ /global/ ) {
678 warn "performing global copy_tree search for $docid\n";
679 return _build_volume_list( { record => $docid } );
684 for my $orgid (@org_ids) {
685 my $vols = _build_volume_list(
686 { record => $docid, owning_lib => $orgid } );
687 warn "Volumes built for org $orgid\n";
688 push( @all_vols, @$vols );
691 warn " $$ Finished copy_tree at " . time() . "\n";
699 sub _build_volume_list {
700 my $search_hash = shift;
702 $search_hash->{deleted} = 'f';
704 my $session = OpenSRF::AppSession->create( "open-ils.storage" );
707 my $request = $session->request(
708 "open-ils.storage.direct.asset.call_number.search.atomic", $search_hash );
709 #"open-ils.storage.direct.asset.call_number.search.atomic", $search_hash );
711 my $vols = $request->gather(1);
714 for my $volume (@$vols) {
716 warn "Grabbing copies for volume: " . $volume->id . "\n";
717 my $creq = $session->request(
718 "open-ils.storage.direct.asset.copy.search_where.atomic",
719 { call_number => $volume->id , deleted => 'f' });
720 #"open-ils.storage.direct.asset.copy.search.call_number.atomic", $volume->id );
722 my $copies = $creq->gather(1);
724 $copies = [ sort { $a->barcode cmp $b->barcode } @$copies ];
726 $volume->copies($copies);
728 push( @volumes, $volume );
732 $session->disconnect();
738 # -----------------------------------------------------------------
739 # Fleshed volume tree batch add/update. This does everything a
740 # volume tree could want, add, update, delete
741 # -----------------------------------------------------------------
742 __PACKAGE__->register_method(
743 method => "volume_tree_fleshed_update",
744 api_name => "open-ils.cat.asset.volume_tree.fleshed.batch.update",
746 sub volume_tree_fleshed_update {
748 my( $self, $client, $user_session, $volumes ) = @_;
749 return undef unless $volumes;
751 my $user_obj = $apputils->check_user_session($user_session);
754 my $session = $apputils->start_db_session();
755 warn "Looping on volumes in fleshed volume tree update\n";
757 # cycle through the volumes provided and update/create/delete where necessary
758 for my $volume (@$volumes) {
760 warn "updating volume " . $volume->id . "\n";
762 my $update_copy_list = $volume->copies;
765 if( $volume->isdeleted) {
766 my $status = _delete_volume($session, $volume, $user_obj);
768 #throw OpenSRF::EX::ERROR
769 #("Volume delete failed for volume " . $volume->id);
771 if(UNIVERSAL::isa($status, "Fieldmapper::perm_ex")) { return $status; }
773 } elsif( $volume->isnew ) {
776 $volume->editor($user_obj->id);
777 $volume->creator($user_obj->id);
778 $volume = _add_volume($session, $volume, $user_obj);
781 if($volume and UNIVERSAL::isa($volume, "Fieldmapper::perm_ex")) { return $volume; }
783 } elsif( $volume->ischanged ) {
785 $volume->editor($user_obj->id);
786 my $stat = _update_volume($session, $volume, $user_obj);
787 if($stat and UNIVERSAL::isa($stat, "Fieldmapper::perm_ex")) { return $stat; }
791 if( ! $volume->isdeleted ) {
792 for my $copy (@{$update_copy_list}) {
794 $copy->editor($user_obj->id);
795 warn "updating copy for volume " . $volume->id . "\n";
800 $copy->call_number($volume->id);
801 $copy->creator($user_obj->id);
802 $copy = _fleshed_copy_update($session,$copy,$user_obj);
804 } elsif( $copy->ischanged ) {
805 $copy->call_number($volume->id);
806 $copy = _fleshed_copy_update($session, $copy, $user_obj);
808 } elsif( $copy->isdeleted ) {
809 warn "Deleting copy " . $copy->id . " for volume " . $volume->id . "\n";
810 my $status = _fleshed_copy_update($session, $copy, $user_obj);
811 warn "Copy delete returned a status of $status\n";
817 $apputils->commit_db_session($session);
818 return scalar(@$volumes);
823 my( $session, $volume, $user_obj ) = @_;
825 if($apputils->check_user_perms(
826 $user_obj->id, $user_obj->home_ou, "DELETE_VOLUME")) {
827 return OpenILS::Perm->new("DELETE_VOLUME"); }
829 #$volume = _find_volume($session, $volume);
830 warn "Deleting volume " . $volume->id . "\n";
832 my $copies = $session->request(
833 "open-ils.storage.direct.asset.copy.search_where.atomic",
834 { call_number => $volume->id, deleted => 'f' } )->gather(1);
835 #"open-ils.storage.direct.asset.copy.search.call_number.atomic",
838 throw OpenSRF::EX::ERROR
839 ("Cannot remove volume with copies attached");
842 my $req = $session->request(
843 "open-ils.storage.direct.asset.call_number.delete",
845 return $req->gather(1);
850 my($session, $volume, $user_obj) = @_;
851 if($apputils->check_user_perms(
852 $user_obj->id, $user_obj->home_ou, "UPDATE_VOLUME")) {
853 return OpenILS::Perm->new("UPDATE_VOLUME"); }
855 my $req = $session->request(
856 "open-ils.storage.direct.asset.call_number.update",
858 my $status = $req->gather(1);
863 my($session, $volume, $user_obj) = @_;
865 if($apputils->check_user_perms(
866 $user_obj->id, $user_obj->home_ou, "CREATE_VOLUME")) {
867 warn "User does not have priveleges to create new volumes\n";
868 return OpenILS::Perm->new("CREATE_VOLUME");
871 my $request = $session->request(
872 "open-ils.storage.direct.asset.call_number.create", $volume );
874 my $id = $request->gather(1);
877 OpenILS::Application::AppUtils->rollback_db_session($session);
878 throw OpenSRF::EX::ERROR (" * -> Error creating new volume");
882 warn "received new volume id: $id\n";
890 __PACKAGE__->register_method(
891 method => "fleshed_copy_update",
892 api_name => "open-ils.cat.asset.copy.fleshed.batch.update",
895 sub fleshed_copy_update {
896 my($self, $client, $user_session, $copies) = @_;
898 my $user_obj = $apputils->check_user_session($user_session);
899 my $session = $apputils->start_db_session();
901 for my $copy (@$copies) {
902 _fleshed_copy_update($session, $copy, $user_obj);
905 $apputils->commit_db_session($session);
912 my($session, $copy, $user_obj) = @_;
914 if($apputils->check_user_perms(
915 $user_obj->id, $user_obj->home_ou, "DELETE_COPY")) {
916 return OpenILS::Perm->new("DELETE_COPY"); }
918 warn "Deleting copy " . $copy->id . "\n";
919 my $request = $session->request(
920 "open-ils.storage.direct.asset.copy.delete",
922 return $request->gather(1);
926 my($session, $copy, $user_obj) = @_;
928 if($apputils->check_user_perms(
929 $user_obj->id, $user_obj->home_ou, "CREATE_COPY")) {
930 return OpenILS::Perm->new("CREATE_COPY"); }
932 my $request = $session->request(
933 "open-ils.storage.direct.asset.copy.create",
935 my $id = $request->gather(1);
938 throw OpenSRF::EX::ERROR
939 ("Unable to create new copy " . Dumper($copy));
942 warn "Created copy " . $copy->id . "\n";
949 my($session, $copy, $user_obj) = @_;
951 my $evt = $apputils->check_perms($user_obj->id, $copy->circ_lib, 'UPDATE_COPY');
952 return $evt if $evt; #XXX NOT YET HANDLED BY CALLER
954 my $status = $apputils->simplereq(
956 "open-ils.storage.direct.asset.copy.update", $copy );
957 $logger->debug("Successfully updated copy " . $copy->id );
962 # -----------------------------------------------------------------
963 # Creates/Updates/Deletes a fleshed asset.copy.
964 # adds/deletes copy stat_cat maps where necessary
965 # -----------------------------------------------------------------
966 sub _fleshed_copy_update {
967 my($session, $copy, $editor) = @_;
969 my $stat_cat_entries = $copy->stat_cat_entries;
970 $copy->editor($editor->id);
972 # in case we're fleshed
973 if(ref($copy->status)) {$copy->status( $copy->status->id ); }
974 if(ref($copy->location)) {$copy->location( $copy->location->id ); }
975 if(ref($copy->circ_lib)) {$copy->circ_lib( $copy->circ_lib->id ); }
977 warn "Updating copy " . Dumper($copy) . "\n";
979 if( $copy->isdeleted ) {
980 return _delete_copy($session, $copy, $editor);
981 } elsif( $copy->isnew ) {
982 $copy = _create_copy($session, $copy, $editor);
983 } elsif( $copy->ischanged ) {
984 _update_copy($session, $copy, $editor);
988 return 1 unless ( $stat_cat_entries and @$stat_cat_entries );
990 my $stat_maps = $session->request(
991 "open-ils.storage.direct.asset.stat_cat_entry_copy_map.search.owning_copy.atomic",
992 $copy->id )->gather(1);
994 if(!$copy->isnew) { _delete_stale_maps($session, $stat_maps, $copy); }
996 # go through the stat cat update/create process
997 for my $stat_entry (@{$stat_cat_entries}){
998 _copy_update_stat_cats( $session, $copy, $stat_maps, $stat_entry, $editor );
1005 # -----------------------------------------------------------------
1006 # Deletes stat maps attached to this copy in the database that
1007 # are no longer attached to the current copy
1008 # -----------------------------------------------------------------
1009 sub _delete_stale_maps {
1010 my( $session, $stat_maps, $copy) = @_;
1012 warn "Deleting stale stat maps for copy " . $copy->id . "\n";
1013 for my $map (@$stat_maps) {
1014 # if there is no stat cat entry on the copy who's id matches the
1015 # current map's id, remove the map from the database
1016 if(! grep { $_->id == $map->stat_cat_entry } @{$copy->stat_cat_entries} ) {
1017 my $req = $session->request(
1018 "open-ils.storage.direct.asset.stat_cat_entry_copy_map.delete", $map );
1027 # -----------------------------------------------------------------
1028 # Searches the stat maps to see if '$entry' already exists on
1029 # the given copy. If it does not, a new stat map is created
1030 # for the given entry and copy
1031 # -----------------------------------------------------------------
1032 sub _copy_update_stat_cats {
1033 my ( $session, $copy, $stat_maps, $entry, $editor ) = @_;
1035 warn "Updating stat maps for copy " . $copy->id . "\n";
1037 # see if this map already exists
1038 for my $map (@$stat_maps) {
1039 if( $map->stat_cat_entry == $entry->id ) {return;}
1042 warn "Creating new stat map for stat " .
1043 $entry->stat_cat . " and copy " . $copy->id . "\n";
1046 my $new_map = Fieldmapper::asset::stat_cat_entry_copy_map->new();
1048 $new_map->stat_cat( $entry->stat_cat );
1049 $new_map->stat_cat_entry( $entry->id );
1050 $new_map->owning_copy( $copy->id );
1052 warn "New map is " . Dumper($new_map) . "\n";
1054 my $request = $session->request(
1055 "open-ils.storage.direct.asset.stat_cat_entry_copy_map.create",
1057 my $status = $request->gather(1);
1058 warn "created new map with id $status\n";
1063 __PACKAGE__->register_method(
1065 api_name => 'open-ils.cat.biblio.records.merge',
1067 Merges a group of records
1068 @param auth The login session key
1069 @param master The id of the record all other r
1070 ecords should be merged into
1071 @param records Array of records to be merged into the master record
1072 @return 1 on success, Event on error.
1077 my( $self, $conn, $auth, $master, $records ) = @_;
1078 my( $reqr, $evt ) = $U->checkses($auth);
1079 return $evt if $evt;
1080 my $editor = OpenILS::Utils::Editor->new( requestor => $reqr, xact => 1 );
1081 my $v = OpenILS::Application::Cat::Merge::merge_records($editor, $master, $records);