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);
753 # first lets see if we have any dup volume labels
755 # my @volumes = @$volumes;
756 # for my $vol (@volumes) {
757 # $volumes{$_->owning_lib} = {} unless $volumes{$_->owning_lib};
758 # $volumes{$_->record} = {} unless $volumes{$_->record};
759 # if($volumes{$_->record}->{$_->label}) {
760 # $logger->info("Duplicate volume label found ".
761 # "for record ".$_->record." and label ".$_->label);
762 # $volumes{$_->record}->{$_->label}++;
764 # $volumes{$_->record}->{$_->label} = 1;
768 # for my $r (values %volumes) {
769 # for my $l (keys %{$volumes{$r}}) {
770 # return OpenILS::Event->new('CALL_NUMBER_EXISTS', payload => $l)
771 # if $volumes{$r}{$l} > 1;
776 my $session = $apputils->start_db_session();
777 warn "Looping on volumes in fleshed volume tree update\n";
779 # cycle through the volumes provided and update/create/delete where necessary
780 for my $volume (@$volumes) {
782 warn "updating volume " . $volume->id . "\n";
784 my $update_copy_list = $volume->copies;
787 if( $volume->isdeleted) {
788 my $status = _delete_volume($session, $volume, $user_obj);
790 #throw OpenSRF::EX::ERROR
791 #("Volume delete failed for volume " . $volume->id);
793 if(UNIVERSAL::isa($status, "Fieldmapper::perm_ex")) { return $status; }
795 } elsif( $volume->isnew ) {
798 $volume->editor($user_obj->id);
799 $volume->creator($user_obj->id);
800 $volume = _add_volume($session, $volume, $user_obj);
803 if($volume and UNIVERSAL::isa($volume, "Fieldmapper::perm_ex")) { return $volume; }
805 } elsif( $volume->ischanged ) {
807 $volume->editor($user_obj->id);
808 my $stat = _update_volume($session, $volume, $user_obj);
809 if($stat and UNIVERSAL::isa($stat, "Fieldmapper::perm_ex")) { return $stat; }
813 if( ! $volume->isdeleted ) {
814 for my $copy (@{$update_copy_list}) {
816 $copy->editor($user_obj->id);
817 warn "updating copy for volume " . $volume->id . "\n";
822 $copy->call_number($volume->id);
823 $copy->creator($user_obj->id);
824 $copy = _fleshed_copy_update($session,$copy,$user_obj);
826 } elsif( $copy->ischanged ) {
827 $copy->call_number($volume->id);
828 $copy = _fleshed_copy_update($session, $copy, $user_obj);
830 } elsif( $copy->isdeleted ) {
831 warn "Deleting copy " . $copy->id . " for volume " . $volume->id . "\n";
832 my $status = _fleshed_copy_update($session, $copy, $user_obj);
833 warn "Copy delete returned a status of $status\n";
839 $apputils->commit_db_session($session);
840 return scalar(@$volumes);
845 my( $session, $volume, $user_obj ) = @_;
847 if($apputils->check_user_perms(
848 $user_obj->id, $user_obj->home_ou, "DELETE_VOLUME")) {
849 return OpenILS::Perm->new("DELETE_VOLUME"); }
851 #$volume = _find_volume($session, $volume);
852 warn "Deleting volume " . $volume->id . "\n";
854 my $copies = $session->request(
855 "open-ils.storage.direct.asset.copy.search_where.atomic",
856 { call_number => $volume->id, deleted => 'f' } )->gather(1);
857 #"open-ils.storage.direct.asset.copy.search.call_number.atomic",
860 throw OpenSRF::EX::ERROR
861 ("Cannot remove volume with copies attached");
864 my $req = $session->request(
865 "open-ils.storage.direct.asset.call_number.delete",
867 return $req->gather(1);
872 my($session, $volume, $user_obj) = @_;
873 if($apputils->check_user_perms(
874 $user_obj->id, $user_obj->home_ou, "UPDATE_VOLUME")) {
875 return OpenILS::Perm->new("UPDATE_VOLUME"); }
877 my $req = $session->request(
878 "open-ils.storage.direct.asset.call_number.update",
880 my $status = $req->gather(1);
885 my($session, $volume, $user_obj) = @_;
887 if($apputils->check_user_perms(
888 $user_obj->id, $user_obj->home_ou, "CREATE_VOLUME")) {
889 warn "User does not have priveleges to create new volumes\n";
890 return OpenILS::Perm->new("CREATE_VOLUME");
893 my $request = $session->request(
894 "open-ils.storage.direct.asset.call_number.create", $volume );
896 my $id = $request->gather(1);
899 OpenILS::Application::AppUtils->rollback_db_session($session);
900 throw OpenSRF::EX::ERROR (" * -> Error creating new volume");
904 warn "received new volume id: $id\n";
912 __PACKAGE__->register_method(
913 method => "fleshed_copy_update",
914 api_name => "open-ils.cat.asset.copy.fleshed.batch.update",
917 sub fleshed_copy_update {
918 my($self, $client, $user_session, $copies) = @_;
920 my $user_obj = $apputils->check_user_session($user_session);
921 my $session = $apputils->start_db_session();
923 for my $copy (@$copies) {
924 _fleshed_copy_update($session, $copy, $user_obj);
927 $apputils->commit_db_session($session);
934 my($session, $copy, $user_obj) = @_;
936 if($apputils->check_user_perms(
937 $user_obj->id, $user_obj->home_ou, "DELETE_COPY")) {
938 return OpenILS::Perm->new("DELETE_COPY"); }
940 warn "Deleting copy " . $copy->id . "\n";
941 my $request = $session->request(
942 "open-ils.storage.direct.asset.copy.delete",
944 return $request->gather(1);
948 my($session, $copy, $user_obj) = @_;
950 if($apputils->check_user_perms(
951 $user_obj->id, $user_obj->home_ou, "CREATE_COPY")) {
952 return OpenILS::Perm->new("CREATE_COPY"); }
954 my $request = $session->request(
955 "open-ils.storage.direct.asset.copy.create",
957 my $id = $request->gather(1);
960 throw OpenSRF::EX::ERROR
961 ("Unable to create new copy " . Dumper($copy));
964 warn "Created copy " . $copy->id . "\n";
971 my($session, $copy, $user_obj) = @_;
973 my $evt = $apputils->check_perms($user_obj->id, $copy->circ_lib, 'UPDATE_COPY');
974 return $evt if $evt; #XXX NOT YET HANDLED BY CALLER
976 my $status = $apputils->simplereq(
978 "open-ils.storage.direct.asset.copy.update", $copy );
979 $logger->debug("Successfully updated copy " . $copy->id );
984 # -----------------------------------------------------------------
985 # Creates/Updates/Deletes a fleshed asset.copy.
986 # adds/deletes copy stat_cat maps where necessary
987 # -----------------------------------------------------------------
988 sub _fleshed_copy_update {
989 my($session, $copy, $editor) = @_;
991 my $stat_cat_entries = $copy->stat_cat_entries;
992 $copy->editor($editor->id);
994 # in case we're fleshed
995 if(ref($copy->status)) {$copy->status( $copy->status->id ); }
996 if(ref($copy->location)) {$copy->location( $copy->location->id ); }
997 if(ref($copy->circ_lib)) {$copy->circ_lib( $copy->circ_lib->id ); }
999 warn "Updating copy " . Dumper($copy) . "\n";
1001 if( $copy->isdeleted ) {
1002 return _delete_copy($session, $copy, $editor);
1003 } elsif( $copy->isnew ) {
1004 $copy = _create_copy($session, $copy, $editor);
1005 } elsif( $copy->ischanged ) {
1006 _update_copy($session, $copy, $editor);
1010 return 1 unless ( $stat_cat_entries and @$stat_cat_entries );
1012 my $stat_maps = $session->request(
1013 "open-ils.storage.direct.asset.stat_cat_entry_copy_map.search.owning_copy.atomic",
1014 $copy->id )->gather(1);
1016 if(!$copy->isnew) { _delete_stale_maps($session, $stat_maps, $copy); }
1018 # go through the stat cat update/create process
1019 for my $stat_entry (@{$stat_cat_entries}){
1020 _copy_update_stat_cats( $session, $copy, $stat_maps, $stat_entry, $editor );
1027 # -----------------------------------------------------------------
1028 # Deletes stat maps attached to this copy in the database that
1029 # are no longer attached to the current copy
1030 # -----------------------------------------------------------------
1031 sub _delete_stale_maps {
1032 my( $session, $stat_maps, $copy) = @_;
1034 warn "Deleting stale stat maps for copy " . $copy->id . "\n";
1035 for my $map (@$stat_maps) {
1036 # if there is no stat cat entry on the copy who's id matches the
1037 # current map's id, remove the map from the database
1038 if(! grep { $_->id == $map->stat_cat_entry } @{$copy->stat_cat_entries} ) {
1039 my $req = $session->request(
1040 "open-ils.storage.direct.asset.stat_cat_entry_copy_map.delete", $map );
1049 # -----------------------------------------------------------------
1050 # Searches the stat maps to see if '$entry' already exists on
1051 # the given copy. If it does not, a new stat map is created
1052 # for the given entry and copy
1053 # -----------------------------------------------------------------
1054 sub _copy_update_stat_cats {
1055 my ( $session, $copy, $stat_maps, $entry, $editor ) = @_;
1057 warn "Updating stat maps for copy " . $copy->id . "\n";
1059 # see if this map already exists
1060 for my $map (@$stat_maps) {
1061 if( $map->stat_cat_entry == $entry->id ) {return;}
1064 warn "Creating new stat map for stat " .
1065 $entry->stat_cat . " and copy " . $copy->id . "\n";
1068 my $new_map = Fieldmapper::asset::stat_cat_entry_copy_map->new();
1070 $new_map->stat_cat( $entry->stat_cat );
1071 $new_map->stat_cat_entry( $entry->id );
1072 $new_map->owning_copy( $copy->id );
1074 warn "New map is " . Dumper($new_map) . "\n";
1076 my $request = $session->request(
1077 "open-ils.storage.direct.asset.stat_cat_entry_copy_map.create",
1079 my $status = $request->gather(1);
1080 warn "created new map with id $status\n";
1085 __PACKAGE__->register_method(
1087 api_name => 'open-ils.cat.biblio.records.merge',
1089 Merges a group of records
1090 @param auth The login session key
1091 @param master The id of the record all other r
1092 ecords should be merged into
1093 @param records Array of records to be merged into the master record
1094 @return 1 on success, Event on error.
1099 my( $self, $conn, $auth, $master, $records ) = @_;
1100 my( $reqr, $evt ) = $U->checkses($auth);
1101 return $evt if $evt;
1102 my %r = map { $_->id => 1 } (@$records, $master); # unique the ids
1103 $records = [ keys %r ];
1104 my $editor = OpenILS::Utils::Editor->new( requestor => $reqr, xact => 1 );
1105 my $v = OpenILS::Application::Cat::Merge::merge_records($editor, $master, $records);
1114 # ---------------------------------------------------------------------------
1115 # ---------------------------------------------------------------------------
1118 __PACKAGE__->register_method(
1119 method => "fleshed_volume_update",
1120 api_name => "open-ils.cat.asset.volume.fleshed.batch.update",
1122 sub fleshed_volume_update {
1123 my( $self, $conn, $auth, $volumes ) = @_;
1124 my( $reqr, $evt ) = $U->checkses($auth);
1125 return $evt if $evt;
1127 my $override = ($self->api_name =~ /override/);
1128 my $editor = OpenILS::Utils::Editor->new( requestor => $reqr, xact => 1 );
1130 for my $vol (@$volumes) {
1131 $logger->info("vol-update: investigating volume ".$vol->id);
1133 $vol->editor($reqr->id);
1134 $vol->edit_date('now');
1136 my $copies = $vol->copies;
1139 if( $vol->isdeleted ) {
1141 $logger->info("vol-update: deleting volume");
1142 my $cs = $editor->search_asset_copy(
1143 { call_number => $vol->id, deleted => 'f' } );
1144 return OpenILS::Event->new(
1145 'VOLUME_NOT_EMPTY', payload => $vol->id ) if @$cs;
1148 $evt = $editor->update_asset_call_number($vol);
1149 return $evt if $evt;
1151 } elsif( $vol->isnew ) {
1152 $logger->info("vol-update: creating volume");
1153 $evt = create_volume( $override, $editor, $vol );
1154 return $evt if $evt;
1156 } elsif( $vol->ischanged ) {
1157 $logger->info("vol-update: update volume");
1158 $evt = $editor->update_asset_call_number($vol);
1159 return $evt if $evt;
1162 # now update any attached copies
1163 if( @$copies and !$vol->isdeleted ) {
1164 $_->call_number($vol->id) for @$copies;
1165 $evt = update_fleshed_copies( $editor, $vol, $copies );
1166 return $evt if $evt;
1171 return scalar(@$volumes);
1175 # this does the actual work
1176 sub update_fleshed_copies {
1177 my( $editor, $vol, $copies ) = @_;
1180 for my $copy (@$copies) {
1182 my $copyid = $copy->id;
1183 $logger->info("vol-update: inspecting copy $copyid");
1185 $copy->editor($editor->requestor->id);
1186 $copy->edit_date('now');
1187 $copy->call_number($vol->id);
1189 $copy->status( $copy->status->id ) if ref($copy->status);
1190 $copy->location( $copy->location->id ) if ref($copy->location);
1191 $copy->circ_lib( $copy->circ_lib->id ) if ref($copy->circ_lib);
1193 my $sc_entries = $copy->stat_cat_entries;
1194 $copy->clear_stat_cat_entries;
1196 if( $copy->isdeleted ) {
1198 $logger->info("vol-update: deleting copy $copyid");
1200 $evt = $editor->update_asset_copy(
1201 $copy, {checkperm=>1, org=>$vol->owning_lib});
1202 return $evt if $evt;
1204 } elsif( $copy->isnew ) {
1205 $evt = create_copy( $editor, $vol, $copy );
1206 return $evt if $evt;
1208 } elsif( $copy->ischanged ) {
1210 $logger->info("vol-update: updating copy $copyid");
1211 $evt = $editor->update_asset_copy(
1212 $copy, {checkperm=>1, org=>$vol->owning_lib});
1213 return $evt if $evt;
1216 $copy->stat_cat_entries( $sc_entries );
1217 $evt = update_copy_stat_entries($editor, $copy);
1218 return $evt if $evt;
1225 my( $editor, $vol, $copy ) = @_;
1227 my $existing = $editor->search_asset_copy(
1228 { call_number => $copy->call_number } );
1230 return OpenILS::Event->new('ITEM_BARCODE_EXISTS') if @$existing;
1233 $copy->creator($editor->requestor->id);
1234 $copy->create_date('now');
1236 my $evt = $editor->create_asset_copy(
1237 $copy, {checkperm=>1, org=>$vol->owning_lib});
1238 return $evt if $evt;
1240 $copy->id($editor->lastid);
1244 sub update_copy_stat_entries {
1245 my( $editor, $copy ) = @_;
1248 my $entries = $copy->stat_cat_entries;
1249 return undef unless ($entries and @$entries);
1251 my $maps = $editor->search_asset_stat_cat_entry_copy_map({copy=>$copy->id});
1254 # if there is no stat cat entry on the copy who's id matches the
1255 # current map's id, remove the map from the database
1256 for my $map (@$maps) {
1257 if(! grep { $_->id == $map->stat_cat_entry } @$entries ) {
1259 $logger->info("copy update found stale ".
1260 "stat cat entry map ".$map->id. " on copy ".$copy->id);
1262 $evt = $editor->delete_asset_stat_cat_entry_copy_map($map);
1263 return $evt if $evt;
1268 # go through the stat cat update/create process
1269 for my $entry (@$entries) {
1271 # if this link already exists in the DB, don't attempt to re-create it
1272 next if( grep{$_->stat_cat_entry == $entry->id} @$maps );
1274 my $new_map = Fieldmapper::asset::stat_cat_entry_copy_map->new();
1276 $new_map->stat_cat( $entry->stat_cat );
1277 $new_map->stat_cat_entry( $entry->id );
1278 $new_map->owning_copy( $copy->id );
1280 $evt = $editor->create_asset_stat_cat_entry_copy_map($new_map);
1281 return $evt if $evt;
1283 $logger->info("copy update created new stat cat entry map ".$editor->lastid);
1291 my( $override, $editor, $vol ) = @_;
1295 # first lets see if there are any collisions
1296 my $vols = $editor->search_asset_call_number( {
1297 owning_lib => $vol->owning_lib,
1298 record => $vol->record,
1299 label => $vol->label
1306 $label = $vol->label;
1308 return OpenILS::Event->new(
1309 'VOLUME_LABEL_EXISTS', payload => $vol->id);
1313 # create a temp label so we can create the volume, then de-dup it
1314 $vol->label( '__SYSTEM_TMP_'.time) if $label;
1316 $vol->creator($editor->requestor->id);
1317 $vol->create_date('now');
1320 $evt = $editor->create_asset_call_number($vol);
1321 return $evt if $evt;
1322 $vol->id($editor->lastid);
1326 # now restore the label and merge into the existing record
1327 $vol->label($label);
1329 OpenILS::Application::Cat::Merge::merge_volumes($editor, [$vol], $$vols[0]);
1330 return $evt if $evt;