Open-ILS/src/perlmods/OpenILS/Application/Vandelay.pm

   1 package OpenILS::Application::Vandelay;
   2 use strict; use warnings;
   3 use OpenILS::Application;
   4 use base qw/OpenILS::Application/;
   5 use Unicode::Normalize;
   6 use OpenSRF::EX qw/:try/;
   7 use OpenSRF::AppSession;
   8 use OpenSRF::Utils::SettingsClient;
   9 use OpenSRF::Utils::Cache;
  10 use OpenILS::Utils::Fieldmapper;
  11 use OpenILS::Utils::CStoreEditor qw/:funcs/;
  12 use MARC::Batch;
  13 use MARC::Record;
  14 use MARC::File::XML;
  15 use OpenILS::Utils::Fieldmapper;
  16 use Time::HiRes qw(time);
  17 use OpenSRF::Utils::Logger qw/$logger/;
  18 use MIME::Base64;
  19 use OpenILS::Const qw/:const/;
  20 use OpenILS::Application::AppUtils;
  21 use OpenILS::Application::Cat::BibCommon;
  22 use OpenILS::Application::Cat::AuthCommon;
  23 use OpenILS::Application::Cat::AssetCommon;
  24 my $U = 'OpenILS::Application::AppUtils';
  25
  26 # A list of LDR/06 values from http://loc.gov/marc
  27 my %record_types = (
  28         a => 'bib',
  29         c => 'bib',
  30         d => 'bib',
  31         e => 'bib',
  32         f => 'bib',
  33         g => 'bib',
  34         i => 'bib',
  35         j => 'bib',
  36         k => 'bib',
  37         m => 'bib',
  38         o => 'bib',
  39         p => 'bib',
  40         r => 'bib',
  41         t => 'bib',
  42         u => 'holdings',
  43         v => 'holdings',
  44         x => 'holdings',
  45         y => 'holdings',
  46         z => 'auth',
  47       ' ' => 'bib',
  48 );
  49
  50 sub initialize {}
  51 sub child_init {}
  52
  53 # --------------------------------------------------------------------------------
  54 # Biblio ingest
  55
  56 sub create_bib_queue {
  57     my $self = shift;
  58     my $client = shift;
  59     my $auth = shift;
  60     my $name = shift;
  61     my $owner = shift;
  62     my $type = shift;
  63     my $import_def = shift;
  64
  65     my $e = new_editor(authtoken => $auth, xact => 1);
  66
  67     return $e->die_event unless $e->checkauth;
  68     return $e->die_event unless $e->allowed('CREATE_BIB_IMPORT_QUEUE');
  69     $owner ||= $e->requestor->id;
  70
  71     return OpenILS::Event->new('BIB_QUEUE_EXISTS')
  72         if $e->search_vandelay_bib_queue(
  73             {name => $name, owner => $owner, queue_type => $type})->[0];
  74
  75     my $queue = new Fieldmapper::vandelay::bib_queue();
  76     $queue->name( $name );
  77     $queue->owner( $owner );
  78     $queue->queue_type( $type ) if ($type);
  79     $queue->item_attr_def( $import_def ) if ($import_def);
  80
  81     my $new_q = $e->create_vandelay_bib_queue( $queue );
  82     return $e->die_event unless ($new_q);
  83     $e->commit;
  84
  85     return $new_q;
  86 }
  87 __PACKAGE__->register_method(
  88     api_name   => "open-ils.vandelay.bib_queue.create",
  89     method     => "create_bib_queue",
  90     api_level  => 1,
  91     argc       => 4,
  92 );
  93
  94
  95 sub create_auth_queue {
  96     my $self = shift;
  97     my $client = shift;
  98     my $auth = shift;
  99     my $name = shift;
 100     my $owner = shift;
 101     my $type = shift;
 102
 103     my $e = new_editor(authtoken => $auth, xact => 1);
 104
 105     return $e->die_event unless $e->checkauth;
 106     return $e->die_event unless $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE');
 107     $owner ||= $e->requestor->id;
 108
 109     return OpenILS::Event->new('AUTH_QUEUE_EXISTS')
 110         if $e->search_vandelay_bib_queue(
 111             {name => $name, owner => $owner, queue_type => $type})->[0];
 112
 113     my $queue = new Fieldmapper::vandelay::authority_queue();
 114     $queue->name( $name );
 115     $queue->owner( $owner );
 116     $queue->queue_type( $type ) if ($type);
 117
 118     my $new_q = $e->create_vandelay_authority_queue( $queue );
 119     $e->die_event unless ($new_q);
 120     $e->commit;
 121
 122     return $new_q;
 123 }
 124 __PACKAGE__->register_method(
 125     api_name   => "open-ils.vandelay.authority_queue.create",
 126     method     => "create_auth_queue",
 127     api_level  => 1,
 128     argc       => 3,
 129 );
 130
 131 sub add_record_to_bib_queue {
 132     my $self = shift;
 133     my $client = shift;
 134     my $auth = shift;
 135     my $queue = shift;
 136     my $marc = shift;
 137     my $purpose = shift;
 138     my $bib_source = shift;
 139
 140     my $e = new_editor(authtoken => $auth, xact => 1);
 141
 142     $queue = $e->retrieve_vandelay_bib_queue($queue);
 143
 144     return $e->die_event unless $e->checkauth;
 145     return $e->die_event unless
 146         ($e->allowed('CREATE_BIB_IMPORT_QUEUE', undef, $queue) ||
 147          $e->allowed('CREATE_BIB_IMPORT_QUEUE'));
 148
 149     my $new_rec = _add_bib_rec($e, $marc, $queue->id, $purpose, $bib_source);
 150
 151     return $e->die_event unless ($new_rec);
 152     $e->commit;
 153     return $new_rec;
 154 }
 155 __PACKAGE__->register_method(
 156     api_name   => "open-ils.vandelay.queued_bib_record.create",
 157     method     => "add_record_to_bib_queue",
 158     api_level  => 1,
 159     argc       => 3,
 160 );
 161
 162 sub _add_bib_rec {
 163     my $e = shift;
 164     my $marc = shift;
 165     my $queue = shift;
 166     my $purpose = shift;
 167     my $bib_source = shift;
 168
 169     my $rec = new Fieldmapper::vandelay::queued_bib_record();
 170     $rec->marc( $marc );
 171     $rec->queue( $queue );
 172     $rec->purpose( $purpose ) if ($purpose);
 173     $rec->bib_source($bib_source);
 174
 175     return $e->create_vandelay_queued_bib_record( $rec );
 176 }
 177
 178 sub add_record_to_authority_queue {
 179     my $self = shift;
 180     my $client = shift;
 181     my $auth = shift;
 182     my $queue = shift;
 183     my $marc = shift;
 184     my $purpose = shift;
 185
 186     my $e = new_editor(authtoken => $auth, xact => 1);
 187
 188     $queue = $e->retrieve_vandelay_authority_queue($queue);
 189
 190     return $e->die_event unless $e->checkauth;
 191     return $e->die_event unless
 192         ($e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE', undef, $queue) ||
 193          $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE'));
 194
 195     my $new_rec = _add_auth_rec($e, $marc, $queue->id, $purpose);
 196
 197     return $e->die_event unless ($new_rec);
 198     $e->commit;
 199     return $new_rec;
 200 }
 201 __PACKAGE__->register_method(
 202     api_name   => "open-ils.vandelay.queued_authority_record.create",
 203     method     => "add_record_to_authority_queue",
 204     api_level  => 1,
 205     argc       => 3,
 206 );
 207
 208 sub _add_auth_rec {
 209     my $e = shift;
 210     my $marc = shift;
 211     my $queue = shift;
 212     my $purpose = shift;
 213
 214     my $rec = new Fieldmapper::vandelay::queued_authority_record();
 215     $rec->marc( $marc );
 216     $rec->queue( $queue );
 217     $rec->purpose( $purpose ) if ($purpose);
 218
 219     return $e->create_vandelay_queued_authority_record( $rec );
 220 }
 221
 222 sub process_spool {
 223     my $self = shift;
 224     my $client = shift;
 225     my $auth = shift;
 226     my $fingerprint = shift || '';
 227     my $queue_id = shift;
 228     my $purpose = shift;
 229     my $filename = shift;
 230     my $bib_source = shift;
 231
 232     my $e = new_editor(authtoken => $auth, xact => 1);
 233     return $e->die_event unless $e->checkauth;
 234
 235     my $queue;
 236     my $type = $self->{record_type};
 237
 238     if($type eq 'bib') {
 239         $queue = $e->retrieve_vandelay_bib_queue($queue_id) or return $e->die_event;
 240     } else {
 241         $queue = $e->retrieve_vandelay_authority_queue($queue_id) or return $e->die_event;
 242     }
 243
 244     my $evt = check_queue_perms($e, $type, $queue);
 245     return $evt if $evt;
 246
 247     my $cache = new OpenSRF::Utils::Cache();
 248
 249     if($fingerprint) {
 250         my $data = $cache->get_cache('vandelay_import_spool_' . $fingerprint);
 251         $purpose = $data->{purpose};
 252         $filename = $data->{path};
 253         $bib_source = $data->{bib_source};
 254     }
 255
 256     unless(-r $filename) {
 257         $logger->error("unable to read MARC file $filename");
 258         return -1; # make this an event XXX
 259     }
 260
 261     $logger->info("vandelay spooling $fingerprint purpose=$purpose file=$filename");
 262
 263     my $marctype = 'USMARC';
 264
 265     open F, $filename;
 266     $marctype = 'XML' if (getc(F) =~ /^\D/o);
 267     close F;
 268
 269     my $batch = new MARC::Batch ($marctype, $filename);
 270     $batch->strict_off;
 271
 272     my $response_scale = 10;
 273     my $count = 0;
 274     my $r = -1;
 275     while (try { $r = $batch->next } otherwise { $r = -1 }) {
 276         if ($r == -1) {
 277             $logger->warn("Processing of record $count in set $filename failed.  Skipping this record");
 278             $count++;
 279         }
 280
 281         $logger->info("processing record $count");
 282
 283         try {
 284             # Avoid an over-eager MARC::File::XML that may try to convert
 285             # our record from MARC8 to UTF8 and break because the record
 286             # is obviously already UTF8
 287             my $ldr = $r->leader();
 288             if (($marctype eq 'XML') && (substr($ldr, 9, 1) ne 'a')) {
 289                 $logger->warn("MARCXML record LDR/09 was not 'a'; record leader may be corrupt");
 290                 substr($ldr,9,1,'a');
 291                 $r->leader($ldr);
 292             }
 293             (my $xml = $r->as_xml_record()) =~ s/\n//sog;
 294             $xml =~ s/^<\?xml.+\?\s*>//go;
 295             $xml =~ s/>\s+</></go;
 296             $xml =~ s/\p{Cc}//go;
 297             $xml = $U->entityize($xml);
 298             $xml =~ s/[\x00-\x1f]//go;
 299
 300             my $qrec;
 301             # Check the leader to ensure we've got something resembling the expected
 302             # Allow spaces to give records the benefit of the doubt
 303             my $ldr_type = substr($r->leader(), 6, 1);
 304             if ($type eq 'bib' && ($record_types{$ldr_type}) eq 'bib' || $ldr_type eq ' ') {
 305                 $qrec = _add_bib_rec( $e, $xml, $queue_id, $purpose, $bib_source ) or return $e->die_event;
 306             } elsif ($type eq 'auth' && ($record_types{$ldr_type}) eq 'auth' || $ldr_type eq ' ') {
 307                 $qrec = _add_auth_rec( $e, $xml, $queue_id, $purpose ) or return $e->die_event;
 308             } else {
 309                 # I don't know how to handle this type; rock on
 310                 $logger->error("In process_spool(), type was $type and leader type was $ldr_type ; not currently supported");
 311                 next;
 312             }
 313
 314             if($self->api_name =~ /stream_results/ and $qrec) {
 315                 $client->respond($qrec->id)
 316             } else {
 317                 $client->respond($count) if (++$count % $response_scale) == 0;
 318                 $response_scale *= 10 if ($count == ($response_scale * 10));
 319             }
 320         } catch Error with {
 321             my $error = shift;
 322             $logger->warn("Encountered a bad record at Vandelay ingest: ".$error);
 323         }
 324     }
 325
 326     $e->commit;
 327     unlink($filename);
 328     $cache->delete_cache('vandelay_import_spool_' . $fingerprint) if $fingerprint;
 329     return $count;
 330 }
 331
 332 __PACKAGE__->register_method(
 333     api_name    => "open-ils.vandelay.bib.process_spool",
 334     method      => "process_spool",
 335     api_level   => 1,
 336     argc        => 3,
 337     record_type => 'bib'
 338 );
 339 __PACKAGE__->register_method(
 340     api_name    => "open-ils.vandelay.auth.process_spool",
 341     method      => "process_spool",
 342     api_level   => 1,
 343     argc        => 3,
 344     record_type => 'auth'
 345 );
 346
 347 __PACKAGE__->register_method(
 348     api_name    => "open-ils.vandelay.bib.process_spool.stream_results",
 349     method      => "process_spool",
 350     api_level   => 1,
 351     argc        => 3,
 352     stream      => 1,
 353     record_type => 'bib'
 354 );
 355 __PACKAGE__->register_method(
 356     api_name    => "open-ils.vandelay.auth.process_spool.stream_results",
 357     method      => "process_spool",
 358     api_level   => 1,
 359     argc        => 3,
 360     stream      => 1,
 361     record_type => 'auth'
 362 );
 363
 364 __PACKAGE__->register_method(
 365     api_name    => "open-ils.vandelay.bib_queue.records.retrieve",
 366     method      => 'retrieve_queued_records',
 367     api_level   => 1,
 368     argc        => 2,
 369     stream      => 1,
 370     record_type => 'bib'
 371 );
 372 __PACKAGE__->register_method(
 373     api_name    => "open-ils.vandelay.auth_queue.records.retrieve",
 374     method      => 'retrieve_queued_records',
 375     api_level   => 1,
 376     argc        => 2,
 377     stream      => 1,
 378     record_type => 'auth'
 379 );
 380
 381 __PACKAGE__->register_method(
 382     api_name    => "open-ils.vandelay.bib_queue.records.matches.retrieve",
 383     method      => 'retrieve_queued_records',
 384     api_level   => 1,
 385     argc        => 2,
 386     stream      => 1,
 387     record_type => 'bib',
 388     signature   => {
 389         desc => q/Only retrieve queued bib records that have matches against existing records/
 390     }
 391 );
 392 __PACKAGE__->register_method(
 393     api_name    => "open-ils.vandelay.auth_queue.records.matches.retrieve",
 394     method      => 'retrieve_queued_records',
 395     api_level   => 1,
 396     argc        => 2,
 397     stream      => 1,
 398     record_type => 'auth',
 399     signature   => {
 400         desc => q/Only retrieve queued authority records that have matches against existing records/
 401     }
 402
 403 );
 404
 405 sub retrieve_queued_records {
 406     my($self, $conn, $auth, $queue_id, $options) = @_;
 407     my $e = new_editor(authtoken => $auth);
 408     return $e->event unless $e->checkauth;
 409     $options ||= {};
 410     my $limit = $$options{limit} || 20;
 411     my $offset = $$options{offset} || 0;
 412
 413     my $type = $self->{record_type};
 414     my $queue;
 415     if($type eq 'bib') {
 416         $queue = $e->retrieve_vandelay_bib_queue($queue_id) or return $e->die_event;
 417     } else {
 418         $queue = $e->retrieve_vandelay_authority_queue($queue_id) or return $e->die_event;
 419     }
 420     my $evt = check_queue_perms($e, $type, $queue);
 421     return $evt if $evt;
 422
 423     my $class = ($type eq 'bib') ? 'vqbr' : 'vqar';
 424     my $search = ($type eq 'bib') ?
 425         'search_vandelay_queued_bib_record' : 'search_vandelay_queued_authority_record';
 426     my $retrieve = ($type eq 'bib') ?
 427         'retrieve_vandelay_queued_bib_record' : 'retrieve_vandelay_queued_authority_record';
 428
 429     my $filter = ($$options{non_imported}) ? {import_time => undef} : {};
 430
 431     my $record_ids;
 432     if($self->api_name =~ /matches/) {
 433         # fetch only matched records
 434         $record_ids = queued_records_with_matches($e, $type, $queue_id, $limit, $offset, $filter);
 435     } else {
 436         # fetch all queue records
 437         $record_ids = $e->$search([
 438                 {queue => $queue_id, %$filter},
 439                 {order_by => {$class => 'id'}, limit => $limit, offset => $offset}
 440             ],
 441             {idlist => 1}
 442         );
 443     }
 444
 445
 446     for my $rec_id (@$record_ids) {
 447         my $params = {
 448             flesh => 1,
 449             flesh_fields => {$class => ['attributes', 'matches']},
 450         };
 451         my $rec = $e->$retrieve([$rec_id, $params]);
 452         $rec->clear_marc if $$options{clear_marc};
 453         $conn->respond($rec);
 454     }
 455     return undef;
 456 }
 457
 458 sub check_queue_perms {
 459     my($e, $type, $queue) = @_;
 460     if ($type eq 'bib') {
 461         return $e->die_event unless
 462             ($e->allowed('CREATE_BIB_IMPORT_QUEUE', undef, $queue) ||
 463              $e->allowed('CREATE_BIB_IMPORT_QUEUE'));
 464     } else {
 465         return $e->die_event unless
 466             ($e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE', undef, $queue) ||
 467              $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE'));
 468     }
 469
 470     return undef;
 471 }
 472
 473 __PACKAGE__->register_method(
 474     api_name    => "open-ils.vandelay.bib_record.list.import",
 475     method      => 'import_record_list',
 476     api_level   => 1,
 477     argc        => 2,
 478     stream      => 1,
 479     record_type => 'bib'
 480 );
 481
 482 __PACKAGE__->register_method(
 483     api_name    => "open-ils.vandelay.auth_record.list.import",
 484     method      => 'import_record_list',
 485     api_level   => 1,
 486     argc        => 2,
 487     stream      => 1,
 488     record_type => 'auth'
 489 );
 490
 491 sub import_record_list {
 492     my($self, $conn, $auth, $rec_ids, $args) = @_;
 493     my $e = new_editor(authtoken => $auth);
 494     return $e->event unless $e->checkauth;
 495     $args ||= {};
 496     my $err = import_record_list_impl($self, $conn, $rec_ids, $e->requestor, $args);
 497     return $err if $err;
 498     return {complete => 1};
 499 }
 500
 501
 502 __PACKAGE__->register_method(
 503     api_name    => "open-ils.vandelay.bib_queue.import",
 504     method      => 'import_queue',
 505     api_level   => 1,
 506     argc        => 2,
 507     stream      => 1,
 508     record_type => 'bib'
 509 );
 510
 511 __PACKAGE__->register_method(
 512     api_name    => "open-ils.vandelay.auth_queue.import",
 513     method      => 'import_queue',
 514     api_level   => 1,
 515     argc        => 2,
 516     stream      => 1,
 517     record_type => 'auth'
 518 );
 519 __PACKAGE__->register_method(
 520     api_name    => "open-ils.vandelay.bib_queue.nomatch.import",
 521     method      => 'import_queue',
 522     api_level   => 1,
 523     argc        => 2,
 524     stream      => 1,
 525     signature   => {
 526         desc => q/Only import records that have no collisions/
 527     },
 528     record_type => 'bib'
 529 );
 530
 531 __PACKAGE__->register_method(
 532     api_name    => "open-ils.vandelay.auth_queue.nomatch.import",
 533     method      => 'import_queue',
 534     api_level   => 1,
 535     argc        => 2,
 536     stream      => 1,
 537     signature   => {
 538         desc => q/Only import records that have no collisions/
 539     },
 540     record_type => 'auth'
 541 );
 542 sub import_queue {
 543     my($self, $conn, $auth, $q_id, $options) = @_;
 544     my $e = new_editor(authtoken => $auth);
 545     return $e->event unless $e->checkauth;
 546     $options ||= {};
 547     my $type = $self->{record_type};
 548     my $class = ($type eq 'bib') ? 'vqbr' : 'vqar';
 549
 550     my $query = {queue => $q_id, import_time => undef};
 551
 552     if($self->api_name =~ /nomatch/) {
 553         my $matched_recs = queued_records_with_matches($e, $type, $q_id, undef, undef, {import_time => undef});
 554         $query->{id} = {'not in' => $matched_recs} if @$matched_recs;
 555     }
 556
 557     my $search = ($type eq 'bib') ?
 558         'search_vandelay_queued_bib_record' : 'search_vandelay_queued_authority_record';
 559     my $rec_ids = $e->$search($query, {idlist => 1});
 560     my $err = import_record_list_impl($self, $conn, $rec_ids, $e->requestor, $options);
 561     return $err if $err;
 562     return {complete => 1};
 563 }
 564
 565 # returns a list of queued record IDs for a given queue that
 566 # have at least one entry in the match table
 567 sub queued_records_with_matches {
 568     my($e, $type, $q_id, $limit, $offset, $filter) = @_;
 569
 570     my $match_class = 'vbm';
 571     my $rec_class = 'vqbr';
 572     if($type eq 'auth') {
 573         $match_class = 'vam';
 574          $rec_class = 'vqar';
 575     }
 576
 577     $filter ||= {};
 578     $filter->{queue} = $q_id;
 579
 580     my $query = {
 581         distinct => 1,
 582         select => {$match_class => ['queued_record']},
 583         from => {
 584             $match_class => {
 585                 $rec_class => {
 586                     field => 'id',
 587                     fkey => 'queued_record',
 588                     filter => $filter,
 589                 }
 590             }
 591         }
 592     };
 593
 594     if($limit or defined $offset) {
 595         $limit ||= 20;
 596         $offset ||= 0;
 597         $query->{limit} = $limit;
 598         $query->{offset} = $offset;
 599     }
 600
 601     my $data = $e->json_query($query);
 602     return [ map {$_->{queued_record}} @$data ];
 603 }
 604
 605 sub import_record_list_impl {
 606     my($self, $conn, $rec_ids, $requestor, $args) = @_;
 607
 608     my $overlay_map = $args->{overlay_map} || {};
 609     my $type = $self->{record_type};
 610     my $total = @$rec_ids;
 611     my $count = 0;
 612     my $step = '1' . '0' x ((length($total) * 3) - 2);
 613     my %queues;
 614     my $auto_overlay_exact = $$args{auto_overlay_exact};
 615     my $auto_overlay_1match = $$args{auto_overlay_1match};
 616     my $merge_profile = $$args{merge_profile};
 617     my $bib_source = $$args{bib_source};
 618
 619     my $overlay_func = 'vandelay.overlay_bib_record';
 620     my $auto_overlay_func = 'vandelay.auto_overlay_bib_record';
 621     my $retrieve_func = 'retrieve_vandelay_queued_bib_record';
 622     my $update_func = 'update_vandelay_queued_bib_record';
 623     my $search_func = 'search_vandelay_queued_bib_record';
 624     my $retrieve_queue_func = 'retrieve_vandelay_bib_queue';
 625     my $update_queue_func = 'update_vandelay_bib_queue';
 626     my $rec_class = 'vqbr';
 627
 628     my %bib_sources;
 629     my $editor = new_editor();
 630     my $sources = $editor->search_config_bib_source({id => {'!=' => undef}});
 631     foreach my $src (@$sources) {
 632         $bib_sources{$src->id} = $src->source;
 633     }
 634
 635     if($type eq 'auth') {
 636         $overlay_func =~ s/bib/auth/o;
 637         $auto_overlay_func = s/bib/auth/o;
 638         $retrieve_func =~ s/bib/authority/o;
 639         $retrieve_queue_func =~ s/bib/authority/o;
 640         $update_queue_func =~ s/bib/authority/o;
 641         $update_func =~ s/bib/authority/o;
 642         $search_func =~ s/bib/authority/o;
 643         $rec_class = 'vqar';
 644     }
 645
 646     for my $rec_id (@$rec_ids) {
 647
 648         my $overlay_target = $overlay_map->{$rec_id};
 649
 650         my $e = new_editor(xact => 1);
 651         $e->requestor($requestor);
 652
 653         my $rec = $e->$retrieve_func([
 654             $rec_id,
 655             {   flesh => 1,
 656                 flesh_fields => { $rec_class => ['matches']},
 657             }
 658         ]);
 659
 660         unless($rec) {
 661             $conn->respond({total => $total, progress => ++$count, imported => $rec_id, err_event => $e->die_event});
 662             $e->rollback;
 663             next;
 664         }
 665
 666         if($rec->import_time) {
 667             $e->rollback;
 668             next;
 669         }
 670
 671         $queues{$rec->queue} = 1;
 672
 673         my $record;
 674         my $imported = 0;
 675
 676         if(defined $overlay_target) {
 677             # Caller chose an explicit overlay target
 678
 679             my $res = $e->json_query(
 680                 {
 681                     from => [
 682                         $overlay_func,
 683                         $rec->id,
 684                         $overlay_target,
 685                         $merge_profile
 686                     ]
 687                 }
 688             )->[0];
 689
 690             if($res->{$overlay_func} eq 't') {
 691                 $logger->info("vl: $type direct overlay succeeded for queued rec " .
 692                     $rec->id . " and overlay target $overlay_target");
 693                 $imported = 1;
 694             }
 695
 696         } else {
 697
 698             if($auto_overlay_1match) {
 699                 # caller says to overlay if there is exactly 1 match
 700
 701                 my %match_recs = map { $_->eg_record => 1 } @{$rec->matches};
 702
 703                 if( scalar(keys %match_recs) == 1) { # all matches point to the same record
 704
 705                     my $res = $e->json_query(
 706                         {
 707                             from => [
 708                                 $overlay_func,
 709                                 $rec->id,
 710                                 $rec->matches->[0]->eg_record,
 711                                 $merge_profile
 712                             ]
 713                         }
 714                     )->[0];
 715
 716                     if($res->{$overlay_func} eq 't') {
 717                         $logger->info("vl: $type overlay-1match succeeded for queued rec " . $rec->id);
 718                         $imported = 1;
 719                     }
 720                 }
 721             }
 722
 723             if(!$imported and $auto_overlay_exact and scalar(@{$rec->matches}) == 1 ) {
 724
 725                 # caller says to overlay if there is an /exact/ match
 726
 727                 my $res = $e->json_query(
 728                     {
 729                         from => [
 730                             $auto_overlay_func,
 731                             $rec->id,
 732                             $merge_profile
 733                         ]
 734                     }
 735                 )->[0];
 736
 737                 if($res->{$auto_overlay_func} eq 't') {
 738                     $logger->info("vl: $type auto-overlay succeeded for queued rec " . $rec->id);
 739                     $imported = 1;
 740                 }
 741             }
 742
 743             if(!$imported) {
 744
 745                 # No overlay / merge occurred.  Do a traditional record import by creating a new record
 746
 747                 if($type eq 'bib') {
 748                     $record = OpenILS::Application::Cat::BibCommon->biblio_record_xml_import($e, $rec->marc, $bib_sources{$rec->bib_source});
 749                 } else {
 750
 751                     $record = OpenILS::Application::Cat::AuthCommon->import_authority_record($e, $rec->marc); #$source);
 752                 }
 753
 754                 if($U->event_code($record)) {
 755
 756                     $e->event($record);
 757
 758                 } else {
 759
 760                     $logger->info("vl: successfully imported new $type record");
 761                     $rec->imported_as($record->id);
 762                     $rec->import_time('now');
 763
 764                     $imported = 1 if $e->$update_func($rec);
 765                 }
 766             }
 767         }
 768
 769         if($imported) {
 770             $e->commit;
 771         } else {
 772             $e->rollback;
 773             # Send an update whenever there's an error
 774             $conn->respond({total => $total, progress => ++$count, imported => $rec_id, err_event => $e->die_event});
 775         }
 776
 777         $conn->respond({total => $total, progress => $count, imported => $rec_id}) if (++$count % $step) == 0;
 778     }
 779
 780     # see if we need to mark any queues as complete
 781     for my $q_id (keys %queues) {
 782
 783         my $e = new_editor(xact => 1);
 784         my $remaining = $e->$search_func(
 785             [{queue => $q_id, import_time => undef}, {limit =>1}], {idlist => 1});
 786
 787         unless(@$remaining) {
 788             my $queue = $e->$retrieve_queue_func($q_id);
 789
 790             unless($U->is_true($queue->complete)) {
 791                 $queue->complete('t');
 792                 $e->$update_queue_func($queue) or return $e->die_event;
 793                 $e->commit;
 794                 next;
 795             }
 796         }
 797         $e->rollback;
 798     }
 799
 800     $conn->respond({total => $total, progress => $count});
 801     return undef;
 802 }
 803
 804
 805 __PACKAGE__->register_method(
 806     api_name    => "open-ils.vandelay.bib_queue.owner.retrieve",
 807     method      => 'owner_queue_retrieve',
 808     api_level   => 1,
 809     argc        => 2,
 810     stream      => 1,
 811     record_type => 'bib'
 812 );
 813 __PACKAGE__->register_method(
 814     api_name    => "open-ils.vandelay.authority_queue.owner.retrieve",
 815     method      => 'owner_queue_retrieve',
 816     api_level   => 1,
 817     argc        => 2,
 818     stream      => 1,
 819     record_type => 'auth'
 820 );
 821
 822 sub owner_queue_retrieve {
 823     my($self, $conn, $auth, $owner_id, $filters) = @_;
 824     my $e = new_editor(authtoken => $auth);
 825     return $e->die_event unless $e->checkauth;
 826     $owner_id = $e->requestor->id; # XXX add support for viewing other's queues?
 827     my $queues;
 828     $filters ||= {};
 829     my $search = {owner => $owner_id};
 830     $search->{$_} = $filters->{$_} for keys %$filters;
 831
 832     if($self->{record_type} eq 'bib') {
 833         $queues = $e->search_vandelay_bib_queue(
 834             [$search, {order_by => {vbq => 'lower(name)'}}]);
 835     } else {
 836         $queues = $e->search_vandelay_authority_queue(
 837             [$search, {order_by => {vaq => 'lower(name)'}}]);
 838     }
 839     $conn->respond($_) for @$queues;
 840     return undef;
 841 }
 842
 843 __PACKAGE__->register_method(
 844     api_name    => "open-ils.vandelay.bib_queue.delete",
 845     method      => "delete_queue",
 846     api_level   => 1,
 847     argc        => 2,
 848     record_type => 'bib'
 849 );
 850 __PACKAGE__->register_method(
 851     api_name    => "open-ils.vandelay.auth_queue.delete",
 852     method      => "delete_queue",
 853     api_level   => 1,
 854     argc        => 2,
 855     record_type => 'auth'
 856 );
 857
 858 sub delete_queue {
 859     my($self, $conn, $auth, $q_id) = @_;
 860     my $e = new_editor(xact => 1, authtoken => $auth);
 861     return $e->die_event unless $e->checkauth;
 862     if($self->{record_type} eq 'bib') {
 863         return $e->die_event unless $e->allowed('CREATE_BIB_IMPORT_QUEUE');
 864         my $queue = $e->retrieve_vandelay_bib_queue($q_id)
 865             or return $e->die_event;
 866         $e->delete_vandelay_bib_queue($queue)
 867             or return $e->die_event;
 868     } else {
 869            return $e->die_event unless $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE');
 870         my $queue = $e->retrieve_vandelay_authority_queue($q_id)
 871             or return $e->die_event;
 872         $e->delete_vandelay_authority_queue($queue)
 873             or return $e->die_event;
 874     }
 875     $e->commit;
 876     return 1;
 877 }
 878
 879
 880 __PACKAGE__->register_method(
 881     api_name    => "open-ils.vandelay.queued_bib_record.html",
 882     method      => 'queued_record_html',
 883     api_level   => 1,
 884     argc        => 2,
 885     stream      => 1,
 886     record_type => 'bib'
 887 );
 888 __PACKAGE__->register_method(
 889     api_name    => "open-ils.vandelay.queued_authority_record.html",
 890     method      => 'queued_record_html',
 891     api_level   => 1,
 892     argc        => 2,
 893     stream      => 1,
 894     record_type => 'auth'
 895 );
 896
 897 sub queued_record_html {
 898     my($self, $conn, $auth, $rec_id) = @_;
 899     my $e = new_editor(authtoken => $auth);
 900     return $e->event unless $e->checkauth;
 901     my $rec;
 902     if($self->{record_type} eq 'bib') {
 903         $rec = $e->retrieve_vandelay_queued_bib_record($rec_id)
 904             or return $e->event;
 905     } else {
 906         $rec = $e->retrieve_vandelay_queued_authority_record($rec_id)
 907             or return $e->event;
 908     }
 909
 910     return $U->simplereq(
 911         'open-ils.search',
 912         'open-ils.search.biblio.record.html', undef, 1, $rec->marc);
 913 }
 914
 915
 916 __PACKAGE__->register_method(
 917     api_name    => "open-ils.vandelay.bib_queue.summary.retrieve",
 918     method      => 'retrieve_queue_summary',
 919     api_level   => 1,
 920     argc        => 2,
 921     stream      => 1,
 922     record_type => 'bib'
 923 );
 924 __PACKAGE__->register_method(
 925     api_name    => "open-ils.vandelay.auth_queue.summary.retrieve",
 926     method      => 'retrieve_queue_summary',
 927     api_level   => 1,
 928     argc        => 2,
 929     stream      => 1,
 930     record_type => 'auth'
 931 );
 932
 933 sub retrieve_queue_summary {
 934     my($self, $conn, $auth, $queue_id) = @_;
 935     my $e = new_editor(authtoken => $auth);
 936     return $e->event unless $e->checkauth;
 937
 938     my $queue;
 939     my $type = $self->{record_type};
 940     if($type eq 'bib') {
 941         $queue = $e->retrieve_vandelay_bib_queue($queue_id)
 942             or return $e->event;
 943     } else {
 944         $queue = $e->retrieve_vandelay_authority_queue($queue_id)
 945             or return $e->event;
 946     }
 947
 948     my $evt = check_queue_perms($e, $type, $queue);
 949     return $evt if $evt;
 950
 951     my $search = 'search_vandelay_queued_bib_record';
 952     $search =~ s/bib/authority/ if $type ne 'bib';
 953
 954     return {
 955         queue => $queue,
 956         total => scalar(@{$e->$search({queue => $queue_id}, {idlist=>1})}),
 957         imported => scalar(@{$e->$search({queue => $queue_id, import_time => {'!=' => undef}}, {idlist=>1})}),
 958     };
 959 }
 960
 961
 962 __PACKAGE__->register_method(
 963     api_name    => "open-ils.vandelay.bib_record.list.asset.import",
 964     method      => 'import_record_list_assets',
 965     api_level   => 1,
 966     argc        => 2,
 967     stream      => 1,
 968     record_type => 'bib'
 969 );
 970 __PACKAGE__->register_method(
 971     api_name    => "open-ils.vandelay.bib_record.queue.asset.import",
 972     method      => 'import_record_queue_assets',
 973     api_level   => 1,
 974     argc        => 2,
 975     stream      => 1,
 976     record_type => 'bib'
 977 );
 978
 979 sub import_record_list_assets {
 980     my($self, $conn, $auth, $import_def, $rec_ids) = @_;
 981     my $e = new_editor(authtoken => $auth);
 982     return $e->event unless $e->checkauth;
 983     my $err = import_record_asset_list_impl($conn, $import_def, $rec_ids, $e->requestor);
 984     return $err if $err;
 985     return {complete => 1};
 986 }
 987
 988 sub import_record_queue_assets {
 989     my($self, $conn, $auth, $import_def, $q_id) = @_;
 990     my $e = new_editor(authtoken => $auth);
 991     return $e->event unless $e->checkauth;
 992     my $rec_ids = $e->search_vandelay_queued_bib_record(
 993         {queue => $q_id, import_time => {'!=' => undef}}, {idlist => 1});
 994     my $err = import_record_asset_list_impl($conn, $import_def, $rec_ids, $e->requestor);
 995     return $err if $err;
 996     return {complete => 1};
 997 }
 998
 999 # --------------------------------------------------------------------------------
1000 # Given a list of queued record IDs, imports all items attached to those records
1001 # --------------------------------------------------------------------------------
1002 sub import_record_asset_list_impl {
1003     my($conn, $import_def, $rec_ids, $requestor) = @_;
1004
1005     my $total = @$rec_ids;
1006     my $try_count = 0;
1007     my $in_count = 0;
1008     my $roe = new_editor(requestor => $requestor);
1009
1010     for my $rec_id (@$rec_ids) {
1011         my $rec = $roe->retrieve_vandelay_queued_bib_record($rec_id);
1012         next unless $rec and $rec->import_time;
1013         my $item_ids = $roe->search_vandelay_import_item({definition => $import_def, record => $rec->id}, {idlist=>1});
1014
1015         for my $item_id (@$item_ids) {
1016             my $e = new_editor(requestor => $requestor, xact => 1);
1017             my $item = $e->retrieve_vandelay_import_item($item_id);
1018             $try_count++;
1019
1020             # --------------------------------------------------------------------------------
1021             # Find or create the volume
1022             # --------------------------------------------------------------------------------
1023             my ($vol, $evt) =
1024                 OpenILS::Application::Cat::AssetCommon->find_or_create_volume(
1025                     $e, $item->call_number, $rec->imported_as, $item->owning_lib);
1026
1027             if($evt) {
1028                 respond_with_status($conn, $total, $try_count, $in_count, $evt);
1029                 $e->rollback;
1030                 next;
1031             }
1032
1033             # --------------------------------------------------------------------------------
1034             # Create the new copy
1035             # --------------------------------------------------------------------------------
1036             my $copy = Fieldmapper::asset::copy->new;
1037             $copy->loan_duration(2);
1038             $copy->fine_level(2);
1039             $copy->barcode($item->barcode);
1040             $copy->location($item->location);
1041             $copy->circ_lib($item->circ_lib || $item->owning_lib);
1042             $copy->status($item->status || OILS_COPY_STATUS_IN_PROCESS);
1043             $copy->circulate($item->circulate);
1044             $copy->deposit($item->deposit);
1045             $copy->deposit_amount($item->deposit_amount);
1046             $copy->ref($item->ref);
1047             $copy->holdable($item->holdable);
1048             $copy->price($item->price);
1049             $copy->circ_as_type($item->circ_as_type);
1050             $copy->alert_message($item->alert_message);
1051             $copy->opac_visible($item->opac_visible);
1052             $copy->circ_modifier($item->circ_modifier);
1053
1054             # --------------------------------------------------------------------------------
1055             # see if a valid circ_modifier was provided
1056             # --------------------------------------------------------------------------------
1057             #if($copy->circ_modifier and not $e->retrieve_config_circ_modifier($item->circ_modifier)) {
1058             if($copy->circ_modifier and not $e->search_config_circ_modifier({code=>$item->circ_modifier})->[0]) {
1059                 respond_with_status($conn, $total, $try_count, $in_count, $e->die_event);
1060                 $e->rollback;
1061                 next;
1062             }
1063
1064             if($evt = OpenILS::Application::Cat::AssetCommon->create_copy($e, $vol, $copy)) {
1065                 $e->rollback;
1066                 respond_with_status($conn, $total, $try_count, $in_count, $evt);
1067                 next;
1068             }
1069
1070             # --------------------------------------------------------------------------------
1071             # create copy notes
1072             # --------------------------------------------------------------------------------
1073             $evt = OpenILS::Application::Cat::AssetCommon->create_copy_note(
1074                 $e, $copy, '', $item->pub_note, 1) if $item->pub_note;
1075
1076             if($evt) {
1077                 respond_with_status($conn, $total, $try_count, $in_count, $evt);
1078                 $e->rollback;
1079                 next;
1080             }
1081
1082             $evt = OpenILS::Application::Cat::AssetCommon->create_copy_note(
1083                 $e, $copy, '', $item->priv_note, 1) if $item->priv_note;
1084
1085             if($evt) {
1086                 respond_with_status($conn, $total, $try_count, $in_count, $evt);
1087                 $e->rollback;
1088                 next;
1089             }
1090
1091             # --------------------------------------------------------------------------------
1092             # Item import succeeded
1093             # --------------------------------------------------------------------------------
1094             $e->commit;
1095             respond_with_status($conn, $total, $try_count, ++$in_count, undef, imported_as => $copy->id);
1096         }
1097     }
1098     return undef;
1099 }
1100
1101
1102 sub respond_with_status {
1103     my($conn, $total, $try_count, $success_count, $err, %args) = @_;
1104     $conn->respond({
1105         total => $total,
1106         progress => $try_count,
1107         err_event => $err,
1108         success_count => $success_count, %args }) if $err or ($try_count % 5 == 0);
1109 }
1110
1111
1112 1;