Open-ILS/src/perlmods/lib/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 ( BinaryEncoding => 'UTF-8' );
  15 use Time::HiRes qw(time);
  16 use OpenSRF::Utils::Logger qw/$logger/;
  17 use MIME::Base64;
  18 use OpenILS::Const qw/:const/;
  19 use OpenILS::Application::AppUtils;
  20 use OpenILS::Application::Cat::BibCommon;
  21 use OpenILS::Application::Cat::AuthCommon;
  22 use OpenILS::Application::Cat::AssetCommon;
  23 my $U = 'OpenILS::Application::AppUtils';
  24
  25 # A list of LDR/06 values from http://loc.gov/marc
  26 my %record_types = (
  27         a => 'bib',
  28         c => 'bib',
  29         d => 'bib',
  30         e => 'bib',
  31         f => 'bib',
  32         g => 'bib',
  33         i => 'bib',
  34         j => 'bib',
  35         k => 'bib',
  36         m => 'bib',
  37         o => 'bib',
  38         p => 'bib',
  39         r => 'bib',
  40         t => 'bib',
  41         u => 'holdings',
  42         v => 'holdings',
  43         x => 'holdings',
  44         y => 'holdings',
  45         z => 'auth',
  46       ' ' => 'bib',
  47 );
  48
  49 sub initialize {}
  50 sub child_init {}
  51
  52 # --------------------------------------------------------------------------------
  53 # Biblio ingest
  54
  55 sub create_bib_queue {
  56     my $self = shift;
  57     my $client = shift;
  58     my $auth = shift;
  59     my $name = shift;
  60     my $owner = shift;
  61     my $type = shift;
  62     my $match_set = 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     if ($e->search_vandelay_bib_queue( {name => $name, owner => $owner, queue_type => $type})->[0]) {
  72         $e->rollback;
  73         return OpenILS::Event->new('BIB_QUEUE_EXISTS')
  74     }
  75
  76     my $queue = new Fieldmapper::vandelay::bib_queue();
  77     $queue->name( $name );
  78     $queue->owner( $owner );
  79     $queue->queue_type( $type ) if ($type);
  80     $queue->item_attr_def( $import_def ) if ($import_def);
  81     $queue->match_set($match_set) if $match_set;
  82
  83     my $new_q = $e->create_vandelay_bib_queue( $queue );
  84     return $e->die_event unless ($new_q);
  85     $e->commit;
  86
  87     return $new_q;
  88 }
  89 __PACKAGE__->register_method(
  90     api_name   => "open-ils.vandelay.bib_queue.create",
  91     method     => "create_bib_queue",
  92     api_level  => 1,
  93     argc       => 4,
  94 );
  95
  96
  97 sub create_auth_queue {
  98     my $self = shift;
  99     my $client = shift;
 100     my $auth = shift;
 101     my $name = shift;
 102     my $owner = shift;
 103     my $type = shift;
 104     my $match_set = shift;
 105
 106     my $e = new_editor(authtoken => $auth, xact => 1);
 107
 108     return $e->die_event unless $e->checkauth;
 109     return $e->die_event unless $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE');
 110     $owner ||= $e->requestor->id;
 111
 112     if ($e->search_vandelay_bib_queue({name => $name, owner => $owner, queue_type => $type})->[0]) {
 113         $e->rollback;
 114         return OpenILS::Event->new('AUTH_QUEUE_EXISTS')
 115     }
 116
 117     my $queue = new Fieldmapper::vandelay::authority_queue();
 118     $queue->name( $name );
 119     $queue->owner( $owner );
 120     $queue->queue_type( $type ) if ($type);
 121
 122     my $new_q = $e->create_vandelay_authority_queue( $queue );
 123     $e->die_event unless ($new_q);
 124     $e->commit;
 125
 126     return $new_q;
 127 }
 128 __PACKAGE__->register_method(
 129     api_name   => "open-ils.vandelay.authority_queue.create",
 130     method     => "create_auth_queue",
 131     api_level  => 1,
 132     argc       => 3,
 133 );
 134
 135 sub add_record_to_bib_queue {
 136     my $self = shift;
 137     my $client = shift;
 138     my $auth = shift;
 139     my $queue = shift;
 140     my $marc = shift;
 141     my $purpose = shift;
 142     my $bib_source = shift;
 143
 144     my $e = new_editor(authtoken => $auth, xact => 1);
 145
 146     $queue = $e->retrieve_vandelay_bib_queue($queue);
 147
 148     return $e->die_event unless $e->checkauth;
 149     return $e->die_event unless
 150         ($e->allowed('CREATE_BIB_IMPORT_QUEUE', undef, $queue) ||
 151          $e->allowed('CREATE_BIB_IMPORT_QUEUE'));
 152
 153     my $new_rec = _add_bib_rec($e, $marc, $queue->id, $purpose, $bib_source);
 154
 155     return $e->die_event unless ($new_rec);
 156     $e->commit;
 157     return $new_rec;
 158 }
 159 __PACKAGE__->register_method(
 160     api_name   => "open-ils.vandelay.queued_bib_record.create",
 161     method     => "add_record_to_bib_queue",
 162     api_level  => 1,
 163     argc       => 3,
 164 );
 165
 166 sub _add_bib_rec {
 167     my $e = shift;
 168     my $marc = shift;
 169     my $queue = shift;
 170     my $purpose = shift;
 171     my $bib_source = shift;
 172
 173     my $rec = new Fieldmapper::vandelay::queued_bib_record();
 174     $rec->marc( $marc );
 175     $rec->queue( $queue );
 176     $rec->purpose( $purpose ) if ($purpose);
 177     $rec->bib_source($bib_source);
 178
 179     return $e->create_vandelay_queued_bib_record( $rec );
 180 }
 181
 182 sub add_record_to_authority_queue {
 183     my $self = shift;
 184     my $client = shift;
 185     my $auth = shift;
 186     my $queue = shift;
 187     my $marc = shift;
 188     my $purpose = shift;
 189
 190     my $e = new_editor(authtoken => $auth, xact => 1);
 191
 192     $queue = $e->retrieve_vandelay_authority_queue($queue);
 193
 194     return $e->die_event unless $e->checkauth;
 195     return $e->die_event unless
 196         ($e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE', undef, $queue) ||
 197          $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE'));
 198
 199     my $new_rec = _add_auth_rec($e, $marc, $queue->id, $purpose);
 200
 201     return $e->die_event unless ($new_rec);
 202     $e->commit;
 203     return $new_rec;
 204 }
 205 __PACKAGE__->register_method(
 206     api_name   => "open-ils.vandelay.queued_authority_record.create",
 207     method     => "add_record_to_authority_queue",
 208     api_level  => 1,
 209     argc       => 3,
 210 );
 211
 212 sub _add_auth_rec {
 213     my $e = shift;
 214     my $marc = shift;
 215     my $queue = shift;
 216     my $purpose = shift;
 217
 218     my $rec = new Fieldmapper::vandelay::queued_authority_record();
 219     $rec->marc( $marc );
 220     $rec->queue( $queue );
 221     $rec->purpose( $purpose ) if ($purpose);
 222
 223     return $e->create_vandelay_queued_authority_record( $rec );
 224 }
 225
 226 sub process_spool {
 227     my $self = shift;
 228     my $client = shift;
 229     my $auth = shift;
 230     my $fingerprint = shift || '';
 231     my $queue_id = shift;
 232     my $purpose = shift;
 233     my $filename = shift;
 234     my $bib_source = shift;
 235
 236     my $e = new_editor(authtoken => $auth, xact => 1);
 237     return $e->die_event unless $e->checkauth;
 238
 239     my $queue;
 240     my $type = $self->{record_type};
 241
 242     if($type eq 'bib') {
 243         $queue = $e->retrieve_vandelay_bib_queue($queue_id) or return $e->die_event;
 244     } else {
 245         $queue = $e->retrieve_vandelay_authority_queue($queue_id) or return $e->die_event;
 246     }
 247
 248     my $evt = check_queue_perms($e, $type, $queue);
 249     return $evt if ($evt);
 250
 251     my $cache = new OpenSRF::Utils::Cache();
 252
 253     if($fingerprint) {
 254         my $data = $cache->get_cache('vandelay_import_spool_' . $fingerprint);
 255         $purpose = $data->{purpose};
 256         $filename = $data->{path};
 257         $bib_source = $data->{bib_source};
 258     }
 259
 260     unless(-r $filename) {
 261         $logger->error("unable to read MARC file $filename");
 262         return -1; # make this an event XXX
 263     }
 264
 265     $logger->info("vandelay spooling $fingerprint purpose=$purpose file=$filename");
 266
 267     my $marctype = 'USMARC';
 268
 269     open F, $filename;
 270     $marctype = 'XML' if (getc(F) =~ /^\D/o);
 271     close F;
 272
 273     my $batch = new MARC::Batch ($marctype, $filename);
 274     $batch->strict_off;
 275
 276     my $response_scale = 10;
 277     my $count = 0;
 278     my $r = -1;
 279     while (try { $r = $batch->next } otherwise { $r = -1 }) {
 280         if ($r == -1) {
 281             $logger->warn("Processing of record $count in set $filename failed.  Skipping this record");
 282             $count++;
 283         }
 284
 285         $logger->info("processing record $count");
 286
 287         try {
 288             (my $xml = $r->as_xml_record()) =~ s/\n//sog;
 289             $xml =~ s/^<\?xml.+\?\s*>//go;
 290             $xml =~ s/>\s+</></go;
 291             $xml =~ s/\p{Cc}//go;
 292             $xml = $U->entityize($xml);
 293             $xml =~ s/[\x00-\x1f]//go;
 294
 295             my $qrec;
 296             # Check the leader to ensure we've got something resembling the expected
 297             # Allow spaces to give records the benefit of the doubt
 298             my $ldr_type = substr($r->leader(), 6, 1);
 299             if ($type eq 'bib' && ($record_types{$ldr_type}) eq 'bib' || $ldr_type eq ' ') {
 300                 $qrec = _add_bib_rec( $e, $xml, $queue_id, $purpose, $bib_source ) or return $e->die_event;
 301             } elsif ($type eq 'auth' && ($record_types{$ldr_type}) eq 'auth' || $ldr_type eq ' ') {
 302                 $qrec = _add_auth_rec( $e, $xml, $queue_id, $purpose ) or return $e->die_event;
 303             } else {
 304                 # I don't know how to handle this type; rock on
 305                 $logger->error("In process_spool(), type was $type and leader type was $ldr_type ; not currently supported");
 306                 next;
 307             }
 308
 309             if($self->api_name =~ /stream_results/ and $qrec) {
 310                 $client->respond($qrec->id)
 311             } else {
 312                 $client->respond($count) if (++$count % $response_scale) == 0;
 313                 $response_scale *= 10 if ($count == ($response_scale * 10));
 314             }
 315         } catch Error with {
 316             my $error = shift;
 317             $logger->warn("Encountered a bad record at Vandelay ingest: ".$error);
 318         }
 319     }
 320
 321     $e->commit;
 322     unlink($filename);
 323     $cache->delete_cache('vandelay_import_spool_' . $fingerprint) if $fingerprint;
 324     return $count;
 325 }
 326
 327 __PACKAGE__->register_method(
 328     api_name    => "open-ils.vandelay.bib.process_spool",
 329     method      => "process_spool",
 330     api_level   => 1,
 331     argc        => 3,
 332     max_chunk_size => 0,
 333     record_type => 'bib'
 334 );
 335 __PACKAGE__->register_method(
 336     api_name    => "open-ils.vandelay.auth.process_spool",
 337     method      => "process_spool",
 338     api_level   => 1,
 339     argc        => 3,
 340     max_chunk_size => 0,
 341     record_type => 'auth'
 342 );
 343
 344 __PACKAGE__->register_method(
 345     api_name    => "open-ils.vandelay.bib.process_spool.stream_results",
 346     method      => "process_spool",
 347     api_level   => 1,
 348     argc        => 3,
 349     stream      => 1,
 350     max_chunk_size => 0,
 351     record_type => 'bib'
 352 );
 353 __PACKAGE__->register_method(
 354     api_name    => "open-ils.vandelay.auth.process_spool.stream_results",
 355     method      => "process_spool",
 356     api_level   => 1,
 357     argc        => 3,
 358     stream      => 1,
 359     max_chunk_size => 0,
 360     record_type => 'auth'
 361 );
 362
 363 __PACKAGE__->register_method(
 364     api_name    => "open-ils.vandelay.bib_queue.records.retrieve",
 365     method      => 'retrieve_queued_records',
 366     api_level   => 1,
 367     argc        => 2,
 368     stream      => 1,
 369     record_type => 'bib'
 370 );
 371 __PACKAGE__->register_method(
 372     api_name    => "open-ils.vandelay.bib_queue.records.retrieve.export.print",
 373     method      => 'retrieve_queued_records',
 374     api_level   => 1,
 375     argc        => 2,
 376     stream      => 1,
 377     record_type => 'bib'
 378 );
 379 __PACKAGE__->register_method(
 380     api_name    => "open-ils.vandelay.bib_queue.records.retrieve.export.csv",
 381     method      => 'retrieve_queued_records',
 382     api_level   => 1,
 383     argc        => 2,
 384     stream      => 1,
 385     record_type => 'bib'
 386 );
 387 __PACKAGE__->register_method(
 388     api_name    => "open-ils.vandelay.bib_queue.records.retrieve.export.email",
 389     method      => 'retrieve_queued_records',
 390     api_level   => 1,
 391     argc        => 2,
 392     stream      => 1,
 393     record_type => 'bib'
 394 );
 395
 396 __PACKAGE__->register_method(
 397     api_name    => "open-ils.vandelay.auth_queue.records.retrieve",
 398     method      => 'retrieve_queued_records',
 399     api_level   => 1,
 400     argc        => 2,
 401     stream      => 1,
 402     record_type => 'auth'
 403 );
 404 __PACKAGE__->register_method(
 405     api_name    => "open-ils.vandelay.auth_queue.records.retrieve.export.print",
 406     method      => 'retrieve_queued_records',
 407     api_level   => 1,
 408     argc        => 2,
 409     stream      => 1,
 410     record_type => 'auth'
 411 );
 412 __PACKAGE__->register_method(
 413     api_name    => "open-ils.vandelay.auth_queue.records.retrieve.export.csv",
 414     method      => 'retrieve_queued_records',
 415     api_level   => 1,
 416     argc        => 2,
 417     stream      => 1,
 418     record_type => 'auth'
 419 );
 420 __PACKAGE__->register_method(
 421     api_name    => "open-ils.vandelay.auth_queue.records.retrieve.export.email",
 422     method      => 'retrieve_queued_records',
 423     api_level   => 1,
 424     argc        => 2,
 425     stream      => 1,
 426     record_type => 'auth'
 427 );
 428
 429 __PACKAGE__->register_method(
 430     api_name    => "open-ils.vandelay.bib_queue.records.matches.retrieve",
 431     method      => 'retrieve_queued_records',
 432     api_level   => 1,
 433     argc        => 2,
 434     stream      => 1,
 435     record_type => 'bib',
 436     signature   => {
 437         desc => q/Only retrieve queued bib records that have matches against existing records/
 438     }
 439 );
 440 __PACKAGE__->register_method(
 441     api_name    => "open-ils.vandelay.auth_queue.records.matches.retrieve",
 442     method      => 'retrieve_queued_records',
 443     api_level   => 1,
 444     argc        => 2,
 445     stream      => 1,
 446     record_type => 'auth',
 447     signature   => {
 448         desc => q/Only retrieve queued authority records that have matches against existing records/
 449     }
 450 );
 451
 452 sub retrieve_queued_records {
 453     my($self, $conn, $auth, $queue_id, $options) = @_;
 454
 455     $options ||= {};
 456     my $limit = $$options{limit} || 20;
 457     my $offset = $$options{offset} || 0;
 458     my $type = $self->{record_type};
 459
 460     my $e = new_editor(authtoken => $auth, xact => 1);
 461     return $e->die_event unless $e->checkauth;
 462
 463     my $queue;
 464     if($type eq 'bib') {
 465         $queue = $e->retrieve_vandelay_bib_queue($queue_id) or return $e->die_event;
 466     } else {
 467         $queue = $e->retrieve_vandelay_authority_queue($queue_id) or return $e->die_event;
 468     }
 469     my $evt = check_queue_perms($e, $type, $queue);
 470     return $evt if ($evt);
 471
 472     my $class = ($type eq 'bib') ? 'vqbr' : 'vqar';
 473     my $query = {
 474         select => {$class => ['id']},
 475         from => $class,
 476         where => {queue => $queue_id},
 477         distinct => 1,
 478         order_by => {$class => ['id']},
 479         limit => $limit,
 480         offset => $offset,
 481     };
 482     if($self->api_name =~ /export/) {
 483         delete $query->{limit};
 484         delete $query->{offset};
 485     }
 486
 487     $query->{where}->{import_time} = undef if $$options{non_imported};
 488
 489     if($$options{with_import_error}) {
 490
 491         $query->{from} = {$class => {vii => {type => 'left'}}};
 492         $query->{where}->{'-or'} = [
 493             {'+vqbr' => {import_error => {'!=' => undef}}},
 494             {'+vii' => {import_error => {'!=' => undef}}}
 495         ];
 496
 497     } else {
 498
 499         if($$options{with_rec_import_error}) {
 500             $query->{where}->{import_error} = {'!=' => undef};
 501
 502         } elsif( $$options{with_item_import_error} and $type eq 'bib') {
 503
 504             $query->{from} = {$class => 'vii'};
 505             $query->{where}->{'+vii'} = {import_error => {'!=' => undef}};
 506         }
 507     }
 508
 509     if($self->api_name =~ /matches/) {
 510         # find only records that have matches
 511         my $mclass = $type eq 'bib' ? 'vbm' : 'vam';
 512         $query->{from} = {$class => {$mclass => {type => 'right'}}};
 513     }
 514
 515     my $record_ids = $e->json_query($query);
 516
 517     my $retrieve = ($type eq 'bib') ?
 518         'retrieve_vandelay_queued_bib_record' : 'retrieve_vandelay_queued_authority_record';
 519     my $search = ($type eq 'bib') ?
 520         'search_vandelay_queued_bib_record' : 'search_vandelay_queued_authority_record';
 521
 522     if ($self->api_name =~ /export/) {
 523         my $rec_list = $e->$search({id => [map { $_->{id} } @$record_ids]}, {substream => 1});
 524         if ($self->api_name =~ /print/) {
 525
 526             $e->rollback;
 527             return $U->fire_object_event(
 528                 undef,
 529                 'vandelay.queued_'.$type.'_record.print',
 530                 $rec_list,
 531                 $e->requestor->ws_ou
 532             );
 533
 534         } elsif ($self->api_name =~ /csv/) {
 535
 536             $e->rollback;
 537             return $U->fire_object_event(
 538                 undef,
 539                 'vandelay.queued_'.$type.'_record.csv',
 540                 $rec_list,
 541                 $e->requestor->ws_ou
 542             );
 543
 544         } elsif ($self->api_name =~ /email/) {
 545
 546             $conn->respond_complete(1);
 547
 548             for my $rec (@$rec_list) {
 549                 $U->create_events_for_hook(
 550                     'vandelay.queued_'.$type.'_record.email',
 551                     $rec,
 552                     $e->requestor->home_ou,
 553                     undef,
 554                     undef,
 555                     1
 556                 );
 557             }
 558
 559         }
 560     } else {
 561         for my $rec_id (@$record_ids) {
 562             my $flesh = ['attributes', 'matches'];
 563             push(@$flesh, 'import_items') if $$options{flesh_import_items};
 564             my $params = {flesh => 1, flesh_fields => {$class => $flesh}};
 565             my $rec = $e->$retrieve([$rec_id->{id}, $params]);
 566             $rec->clear_marc if $$options{clear_marc};
 567             $conn->respond($rec);
 568         }
 569     }
 570
 571     $e->rollback;
 572     return undef;
 573 }
 574
 575 __PACKAGE__->register_method(
 576     api_name    => 'open-ils.vandelay.import_item.queue.retrieve',
 577     method      => 'retrieve_queue_import_items',
 578     api_level   => 1,
 579     argc        => 2,
 580     stream      => 1,
 581     authoritative => 1,
 582     signature => q/
 583         Returns Import Item (vii) objects for the selected queue.
 584         Filter options:
 585             with_import_error : only return items that failed to import
 586     /
 587 );
 588 __PACKAGE__->register_method(
 589     api_name    => 'open-ils.vandelay.import_item.queue.export.print',
 590     method      => 'retrieve_queue_import_items',
 591     api_level   => 1,
 592     argc        => 2,
 593     stream      => 1,
 594     authoritative => 1,
 595     signature => q/
 596         Returns template-generated printable output of Import Item (vii) objects for the selected queue.
 597         Filter options:
 598             with_import_error : only return items that failed to import
 599     /
 600 );
 601 __PACKAGE__->register_method(
 602     api_name    => 'open-ils.vandelay.import_item.queue.export.csv',
 603     method      => 'retrieve_queue_import_items',
 604     api_level   => 1,
 605     argc        => 2,
 606     stream      => 1,
 607     authoritative => 1,
 608     signature => q/
 609         Returns template-generated CSV output of Import Item (vii) objects for the selected queue.
 610         Filter options:
 611             with_import_error : only return items that failed to import
 612     /
 613 );
 614 __PACKAGE__->register_method(
 615     api_name    => 'open-ils.vandelay.import_item.queue.export.email',
 616     method      => 'retrieve_queue_import_items',
 617     api_level   => 1,
 618     argc        => 2,
 619     stream      => 1,
 620     authoritative => 1,
 621     signature => q/
 622         Emails template-generated output of Import Item (vii) objects for the selected queue.
 623         Filter options:
 624             with_import_error : only return items that failed to import
 625     /
 626 );
 627
 628 sub retrieve_queue_import_items {
 629     my($self, $conn, $auth, $q_id, $options) = @_;
 630
 631     $options ||= {};
 632     my $limit = $$options{limit} || 20;
 633     my $offset = $$options{offset} || 0;
 634
 635     my $e = new_editor(authtoken => $auth);
 636     return $e->event unless $e->checkauth;
 637
 638     my $queue = $e->retrieve_vandelay_bib_queue($q_id) or return $e->event;
 639     my $evt = check_queue_perms($e, 'bib', $queue);
 640     return $evt if $evt;
 641
 642     my $query = {
 643         select => {vii => ['id']},
 644         from => {
 645             vii => {
 646                 vqbr => {
 647                     join => {
 648                         'vbq' => {
 649                             field => 'id',
 650                             fkey => 'queue',
 651                             filter => {id => $q_id}
 652                         }
 653                     }
 654                 }
 655             }
 656         },
 657         order_by => {'vii' => ['record','id']},
 658         limit => $limit,
 659         offset => $offset
 660     };
 661     if($self->api_name =~ /export/) {
 662         delete $query->{limit};
 663         delete $query->{offset};
 664     }
 665
 666     $query->{where} = {'+vii' => {import_error => {'!=' => undef}}}
 667         if $$options{with_import_error};
 668
 669     my $items = $e->json_query($query);
 670     my $item_list = $e->search_vandelay_import_item({id => [map { $_->{id} } @$items]});
 671     if ($self->api_name =~ /export/) {
 672         if ($self->api_name =~ /print/) {
 673
 674             return $U->fire_object_event(
 675                 undef,
 676                 'vandelay.import_items.print',
 677                 $item_list,
 678                 $e->requestor->ws_ou
 679             );
 680
 681         } elsif ($self->api_name =~ /csv/) {
 682
 683             return $U->fire_object_event(
 684                 undef,
 685                 'vandelay.import_items.csv',
 686                 $item_list,
 687                 $e->requestor->ws_ou
 688             );
 689
 690         } elsif ($self->api_name =~ /email/) {
 691
 692             $conn->respond_complete(1);
 693
 694             for my $item (@$item_list) {
 695                 $U->create_events_for_hook(
 696                     'vandelay.import_items.email',
 697                     $item,
 698                     $e->requestor->home_ou,
 699                     undef,
 700                     undef,
 701                     1
 702                 );
 703             }
 704
 705         }
 706     } else {
 707         for my $item (@$item_list) {
 708             $conn->respond($item);
 709         }
 710     }
 711
 712     return undef;
 713 }
 714
 715 sub check_queue_perms {
 716     my($e, $type, $queue) = @_;
 717     if ($type eq 'bib') {
 718         return $e->die_event unless
 719             ($e->allowed('CREATE_BIB_IMPORT_QUEUE', undef, $queue) ||
 720              $e->allowed('CREATE_BIB_IMPORT_QUEUE'));
 721     } else {
 722         return $e->die_event unless
 723             ($e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE', undef, $queue) ||
 724              $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE'));
 725     }
 726
 727     return undef;
 728 }
 729
 730 __PACKAGE__->register_method(
 731     api_name    => "open-ils.vandelay.bib_record.list.import",
 732     method      => 'import_record_list',
 733     api_level   => 1,
 734     argc        => 2,
 735     stream      => 1,
 736     record_type => 'bib'
 737 );
 738
 739 __PACKAGE__->register_method(
 740     api_name    => "open-ils.vandelay.auth_record.list.import",
 741     method      => 'import_record_list',
 742     api_level   => 1,
 743     argc        => 2,
 744     stream      => 1,
 745     record_type => 'auth'
 746 );
 747
 748 sub import_record_list {
 749     my($self, $conn, $auth, $rec_ids, $args) = @_;
 750     my $e = new_editor(authtoken => $auth, xact => 1);
 751     return $e->die_event unless $e->checkauth;
 752     $args ||= {};
 753     my $err = import_record_list_impl($self, $conn, $rec_ids, $e->requestor, $args);
 754     try {$e->rollback} otherwise {};
 755     return $err if $err;
 756     return {complete => 1};
 757 }
 758
 759
 760 __PACKAGE__->register_method(
 761     api_name    => "open-ils.vandelay.bib_queue.import",
 762     method      => 'import_queue',
 763     api_level   => 1,
 764     argc        => 2,
 765     stream      => 1,
 766     max_chunk_size => 0,
 767     record_type => 'bib',
 768     signature => {
 769         desc => q/
 770             Attempts to import all non-imported records for the selected queue.
 771             Will also attempt import of all non-imported items.
 772         /
 773     }
 774 );
 775
 776 __PACKAGE__->register_method(
 777     api_name    => "open-ils.vandelay.auth_queue.import",
 778     method      => 'import_queue',
 779     api_level   => 1,
 780     argc        => 2,
 781     stream      => 1,
 782     max_chunk_size => 0,
 783     record_type => 'auth'
 784 );
 785
 786 sub import_queue {
 787     my($self, $conn, $auth, $q_id, $options) = @_;
 788     my $e = new_editor(authtoken => $auth, xact => 1);
 789     return $e->die_event unless $e->checkauth;
 790     $options ||= {};
 791     my $type = $self->{record_type};
 792     my $class = ($type eq 'bib') ? 'vqbr' : 'vqar';
 793
 794     # First, collect the not-yet-imported records
 795     my $query = {queue => $q_id, import_time => undef};
 796     my $search = ($type eq 'bib') ?
 797         'search_vandelay_queued_bib_record' :
 798         'search_vandelay_queued_authority_record';
 799     my $rec_ids = $e->$search($query, {idlist => 1});
 800
 801     # Now add any imported records that have un-imported items
 802
 803     if($type eq 'bib') {
 804         my $item_recs = $e->json_query({
 805             select => {vqbr => ['id']},
 806             from => {vqbr => 'vii'},
 807             where => {
 808                 '+vqbr' => {
 809                     queue => $q_id,
 810                     import_time => {'!=' => undef}
 811                 },
 812                 '+vii' => {import_time => undef}
 813             },
 814             distinct => 1
 815         });
 816         push(@$rec_ids, map {$_->{id}} @$item_recs);
 817     }
 818
 819     my $err = import_record_list_impl($self, $conn, $rec_ids, $e->requestor, $options);
 820     try {$e->rollback} otherwise {}; # only using this to make the read authoritative -- don't die from it
 821     return $err if $err;
 822     return {complete => 1};
 823 }
 824
 825 # returns a list of queued record IDs for a given queue that
 826 # have at least one entry in the match table
 827 # XXX DEPRECATED?
 828 sub queued_records_with_matches {
 829     my($e, $type, $q_id, $limit, $offset, $filter) = @_;
 830
 831     my $match_class = 'vbm';
 832     my $rec_class = 'vqbr';
 833     if($type eq 'auth') {
 834         $match_class = 'vam';
 835          $rec_class = 'vqar';
 836     }
 837
 838     $filter ||= {};
 839     $filter->{queue} = $q_id;
 840
 841     my $query = {
 842         distinct => 1,
 843         select => {$match_class => ['queued_record']},
 844         from => {
 845             $match_class => {
 846                 $rec_class => {
 847                     field => 'id',
 848                     fkey => 'queued_record',
 849                     filter => $filter,
 850                 }
 851             }
 852         }
 853     };
 854
 855     if($limit or defined $offset) {
 856         $limit ||= 20;
 857         $offset ||= 0;
 858         $query->{limit} = $limit;
 859         $query->{offset} = $offset;
 860     }
 861
 862     my $data = $e->json_query($query);
 863     return [ map {$_->{queued_record}} @$data ];
 864 }
 865
 866
 867 sub import_record_list_impl {
 868     my($self, $conn, $rec_ids, $requestor, $args) = @_;
 869
 870     my $overlay_map = $args->{overlay_map} || {};
 871     my $type = $self->{record_type};
 872     my %queues;
 873
 874     my $report_args = {
 875         progress => 1,
 876         step => 1,
 877         conn => $conn,
 878         total => scalar(@$rec_ids),
 879         report_all => $$args{report_all}
 880     };
 881
 882     my $auto_overlay_exact = $$args{auto_overlay_exact};
 883     my $auto_overlay_1match = $$args{auto_overlay_1match};
 884     my $auto_overlay_best = $$args{auto_overlay_best_match};
 885     my $match_quality_ratio = $$args{match_quality_ratio};
 886     my $merge_profile = $$args{merge_profile};
 887     my $ft_merge_profile = $$args{fall_through_merge_profile};
 888     my $bib_source = $$args{bib_source};
 889     my $import_no_match = $$args{import_no_match};
 890
 891     my $overlay_func = 'vandelay.overlay_bib_record';
 892     my $auto_overlay_func = 'vandelay.auto_overlay_bib_record';
 893     my $auto_overlay_best_func = 'vandelay.auto_overlay_bib_record_with_best'; # XXX bib-only
 894     my $retrieve_func = 'retrieve_vandelay_queued_bib_record';
 895     my $update_func = 'update_vandelay_queued_bib_record';
 896     my $search_func = 'search_vandelay_queued_bib_record';
 897     my $retrieve_queue_func = 'retrieve_vandelay_bib_queue';
 898     my $update_queue_func = 'update_vandelay_bib_queue';
 899     my $rec_class = 'vqbr';
 900
 901     my $editor = new_editor();
 902
 903     my %bib_sources;
 904     my $sources = $editor->search_config_bib_source({id => {'!=' => undef}});
 905     $bib_sources{$_->id} = $_->source for @$sources;
 906
 907     if($type eq 'auth') {
 908         $overlay_func =~ s/bib/auth/o;
 909         $auto_overlay_func = s/bib/auth/o;
 910         $retrieve_func =~ s/bib/authority/o;
 911         $retrieve_queue_func =~ s/bib/authority/o;
 912         $update_queue_func =~ s/bib/authority/o;
 913         $update_func =~ s/bib/authority/o;
 914         $search_func =~ s/bib/authority/o;
 915         $rec_class = 'vqar';
 916     }
 917
 918     my @success_rec_ids;
 919     for my $rec_id (@$rec_ids) {
 920
 921         my $error = 0;
 922         my $overlay_target = $overlay_map->{$rec_id};
 923
 924         my $e = new_editor(xact => 1);
 925         $e->requestor($requestor);
 926
 927         $$report_args{e} = $e;
 928         $$report_args{evt} = undef;
 929         $$report_args{import_error} = undef;
 930
 931         my $rec = $e->$retrieve_func([
 932             $rec_id,
 933             {   flesh => 1,
 934                 flesh_fields => { $rec_class => ['matches']},
 935             }
 936         ]);
 937
 938         unless($rec) {
 939             $$report_args{evt} = $e->event;
 940             finish_rec_import_attempt($report_args);
 941             next;
 942         }
 943
 944         if($rec->import_time) {
 945             # if the record is already imported, that means it may have
 946             # un-imported copies.  Add to success list for later processing.
 947             push(@success_rec_ids, $rec_id);
 948             $e->rollback;
 949             next;
 950         }
 951
 952         $$report_args{rec} = $rec;
 953         $queues{$rec->queue} = 1;
 954
 955         my $record;
 956         my $imported = 0;
 957
 958         if(defined $overlay_target) {
 959             # Caller chose an explicit overlay target
 960
 961             my $res = $e->json_query(
 962                 {
 963                     from => [
 964                         $overlay_func,
 965                         $rec_id,
 966                         $overlay_target,
 967                         $merge_profile
 968                     ]
 969                 }
 970             );
 971
 972             if($res and ($res = $res->[0])) {
 973
 974                 if($res->{$overlay_func} eq 't') {
 975                     $logger->info("vl: $type direct overlay succeeded for queued rec ".
 976                         "$rec_id and overlay target $overlay_target");
 977                     $imported = 1;
 978                 }
 979
 980             } else {
 981                 $error = 1;
 982                 $logger->error("vl: Error attempting overlay with func=$overlay_func, profile=$merge_profile, record=$rec_id");
 983             }
 984
 985         } else {
 986
 987             if($auto_overlay_1match) { # overlay if there is exactly 1 match
 988
 989                 my %match_recs = map { $_->eg_record => 1 } @{$rec->matches};
 990
 991                 if( scalar(keys %match_recs) == 1) { # all matches point to the same record
 992
 993                     ($imported, $error, $rec) = try_auto_overlay(
 994                         $e, $type,
 995                         $report_args,
 996                         $auto_overlay_best_func,
 997                         $retrieve_func,
 998                         $rec_class,
 999                         $rec_id,
1000                         $match_quality_ratio,
1001                         $merge_profile,
1002                         $ft_merge_profile
1003                     );
1004                 }
1005             }
1006
1007             if(!$imported and !$error and $auto_overlay_exact and scalar(@{$rec->matches}) == 1 ) {
1008
1009                 # caller says to overlay if there is an /exact/ match
1010                 # $auto_overlay_func only proceeds and returns true on exact matches
1011
1012                 my $res = $e->json_query(
1013                     {
1014                         from => [
1015                             $auto_overlay_func,
1016                             $rec_id,
1017                             $merge_profile
1018                         ]
1019                     }
1020                 );
1021
1022                 if($res and ($res = $res->[0])) {
1023
1024                     if($res->{$auto_overlay_func} eq 't') {
1025                         $logger->info("vl: $type auto-overlay succeeded for queued rec $rec_id");
1026                         $imported = 1;
1027
1028                         # re-fetch the record to pick up the imported_as value from the DB
1029                         $$report_args{rec} = $rec = $e->$retrieve_func([
1030                             $rec_id, {flesh => 1, flesh_fields => {$rec_class => ['matches']}}]);
1031
1032                     } else {
1033                         $logger->info("vl: $type auto-overlay failed for queued rec $rec_id");
1034                     }
1035
1036                 } else {
1037                     $error = 1;
1038                     $logger->error("vl: Error attempting overlay with func=$auto_overlay_func, profile=$merge_profile, record=$rec_id");
1039                 }
1040             }
1041
1042             if(!$imported and !$error and $auto_overlay_best and scalar(@{$rec->matches}) > 0 ) {
1043                 # caller says to overlay the best match
1044
1045                 ($imported, $error, $rec) = try_auto_overlay(
1046                     $e, $type,
1047                     $report_args,
1048                     $auto_overlay_best_func,
1049                     $retrieve_func,
1050                     $rec_class,
1051                     $rec_id,
1052                     $match_quality_ratio,
1053                     $merge_profile,
1054                     $ft_merge_profile
1055                 );
1056             }
1057
1058             if(!$imported and !$error and $import_no_match and scalar(@{$rec->matches}) == 0) {
1059
1060                 # No overlay / merge occurred.  Do a traditional record import by creating a new record
1061
1062                 $logger->info("vl: creating new $type record for queued record $rec_id");
1063                 if($type eq 'bib') {
1064                     $record = OpenILS::Application::Cat::BibCommon->biblio_record_xml_import(
1065                         $e, $rec->marc, $bib_sources{$rec->bib_source}, undef, 1);
1066                 } else {
1067
1068                     $record = OpenILS::Application::Cat::AuthCommon->import_authority_record($e, $rec->marc); #$source);
1069                 }
1070
1071                 if($U->event_code($record)) {
1072                     $$report_args{import_error} = 'import.duplicate.tcn'
1073                         if $record->{textcode} eq 'OPEN_TCN_NOT_FOUND';
1074                     $$report_args{evt} = $record;
1075
1076                 } else {
1077
1078                     $logger->info("vl: successfully imported new $type record");
1079                     $rec->imported_as($record->id);
1080                     $imported = 1;
1081                 }
1082             }
1083         }
1084
1085         if($imported) {
1086
1087             $rec->import_time('now');
1088             $rec->clear_import_error;
1089             $rec->clear_error_detail;
1090
1091             if($e->$update_func($rec)) {
1092
1093                 push @success_rec_ids, $rec_id;
1094                 finish_rec_import_attempt($report_args);
1095
1096             } else {
1097                 $imported = 0;
1098             }
1099         }
1100
1101         if(!$imported) {
1102             $logger->info("vl: record $rec_id was not imported");
1103             $$report_args{evt} = $e->event unless $$report_args{evt};
1104             finish_rec_import_attempt($report_args);
1105         }
1106     }
1107
1108     # see if we need to mark any queues as complete
1109     for my $q_id (keys %queues) {
1110
1111         my $e = new_editor(xact => 1);
1112         my $remaining = $e->$search_func(
1113             [{queue => $q_id, import_time => undef}, {limit =>1}], {idlist => 1});
1114
1115         unless(@$remaining) {
1116             my $queue = $e->$retrieve_queue_func($q_id);
1117
1118             unless($U->is_true($queue->complete)) {
1119                 $queue->complete('t');
1120                 $e->$update_queue_func($queue) or return $e->die_event;
1121                 $e->commit;
1122                 next;
1123             }
1124         }
1125         $e->rollback;
1126     }
1127
1128     # import the copies
1129     import_record_asset_list_impl($conn, \@success_rec_ids, $requestor) if @success_rec_ids;
1130
1131     $conn->respond({total => $$report_args{total}, progress => $$report_args{progress}});
1132     return undef;
1133 }
1134
1135
1136 sub try_auto_overlay {
1137     my $e = shift;
1138     my $type = shift;
1139     my $report_args = shift;
1140     my $overlay_func  = shift;
1141     my $retrieve_func = shift;
1142     my $rec_class = shift;
1143     my $rec_id  = shift;
1144     my $match_quality_ratio = shift;
1145     my $merge_profile  = shift;
1146     my $ft_merge_profile = shift;
1147
1148     my $imported = 0;
1149     my $error = 0;
1150
1151     # Find the best match and overlay if the quality ratio allows it.
1152     my $res = $e->json_query(
1153         {
1154             from => [
1155                 $overlay_func,
1156                 $rec_id,
1157                 $merge_profile,
1158                 $match_quality_ratio
1159             ]
1160         }
1161     );
1162
1163     if($res and ($res = $res->[0])) {
1164
1165         if($res->{$overlay_func} eq 't') {
1166
1167             # first attempt succeeded
1168             $imported = 1;
1169
1170         } else {
1171
1172             # quality-limited merge failed with insufficient quality.  If there is a
1173             # fall-through merge profile, re-do the merge with the alternate profile
1174             # and no quality restriction.
1175
1176             if($ft_merge_profile and $match_quality_ratio > 0) {
1177
1178                 $logger->info("vl: $type auto-merge failed with profile $merge_profile; ".
1179                     "re-merging with fall-through profile $ft_merge_profile");
1180
1181                 my $res = $e->json_query(
1182                     {
1183                         from => [
1184                             $overlay_func,
1185                             $rec_id,
1186                             $ft_merge_profile,
1187                             0 # minimum quality not required
1188                         ]
1189                     }
1190                 );
1191
1192                 if($res and ($res = $res->[0])) {
1193
1194                     if($res->{$overlay_func} eq 't') {
1195
1196                         # second attempt succeeded
1197                         $imported = 1;
1198
1199                     } else {
1200
1201                         # failed to merge on second attempt
1202                         $logger->info("vl: $type auto-merge with fall-through failed for queued rec $rec_id");
1203                     }
1204                 } else {
1205
1206                     # second attempt died
1207                     $error = 1;
1208                     $logger->error("vl: Error attempting overlay with func=$overlay_func, profile=$merge_profile, record=$rec_id");
1209                 }
1210
1211             } else {
1212
1213                 # failed to merge on first attempt, no fall-through was provided
1214                 $$report_args{import_error} = 'overlay.record.quality' if $match_quality_ratio > 0;
1215                 $logger->info("vl: $type auto-merge failed for queued rec $rec_id");
1216             }
1217         }
1218
1219     } else {
1220
1221         # first attempt died
1222         $error = 1;
1223         $logger->error("vl: Error attempting overlay with func=$overlay_func, profile=$merge_profile, record=$rec_id");
1224     }
1225
1226     if($imported) {
1227
1228         # at least 1 of the attempts succeeded
1229         $logger->info("vl: $type auto-merge succeeded for queued rec $rec_id");
1230
1231         # re-fetch the record to pick up the imported_as value from the DB
1232         $$report_args{rec} = $e->$retrieve_func([
1233             $rec_id, {flesh => 1, flesh_fields => {$rec_class => ['matches']}}]);
1234     }
1235
1236     return ($imported, $error, $$report_args{rec});
1237 }
1238
1239
1240 # tracks any import errors, commits the current xact, responds to the client
1241 sub finish_rec_import_attempt {
1242     my $args = shift;
1243     my $evt = $$args{evt};
1244     my $rec = $$args{rec};
1245     my $e = $$args{e};
1246
1247     my $error = $$args{import_error};
1248     $error = 'general.unknown' if $evt and not $error;
1249
1250     # error tracking
1251     if($rec) {
1252
1253         if($error or $evt) {
1254             # failed import
1255             # since an error occurred, there's no guarantee the transaction wasn't
1256             # rolled back.  force a rollback and create a new editor.
1257             $e->rollback;
1258             $e = new_editor(xact => 1);
1259             $rec->import_error($error);
1260
1261             if($evt) {
1262                 my $detail = sprintf("%s : %s", $evt->{textcode}, substr($evt->{desc}, 0, 140));
1263                 $rec->error_detail($detail);
1264             }
1265
1266             my $method = 'update_vandelay_queued_bib_record';
1267             $method =~ s/bib/authority/ if $$args{type} eq 'auth';
1268             $e->$method($rec) and $e->commit or $e->rollback;
1269
1270         } else {
1271             # commit the successful import
1272             $e->commit;
1273         }
1274
1275     } else {
1276         # requested queued record was not found
1277         $e->rollback;
1278     }
1279
1280     # respond to client
1281     if($$args{report_all} or ($$args{progress} % $$args{step}) == 0) {
1282         $$args{conn}->respond({
1283             total => $$args{total},
1284             progress => $$args{progress},
1285             imported => ($rec) ? $rec->id : undef,
1286             err_event => $evt
1287         });
1288         $$args{step} *= 2 unless $$args{step} == 256;
1289     }
1290
1291     $$args{progress}++;
1292 }
1293
1294
1295
1296
1297
1298 __PACKAGE__->register_method(
1299     api_name    => "open-ils.vandelay.bib_queue.owner.retrieve",
1300     method      => 'owner_queue_retrieve',
1301     api_level   => 1,
1302     argc        => 2,
1303     stream      => 1,
1304     record_type => 'bib'
1305 );
1306 __PACKAGE__->register_method(
1307     api_name    => "open-ils.vandelay.authority_queue.owner.retrieve",
1308     method      => 'owner_queue_retrieve',
1309     api_level   => 1,
1310     argc        => 2,
1311     stream      => 1,
1312     record_type => 'auth'
1313 );
1314
1315 sub owner_queue_retrieve {
1316     my($self, $conn, $auth, $owner_id, $filters) = @_;
1317     my $e = new_editor(authtoken => $auth, xact => 1);
1318     return $e->die_event unless $e->checkauth;
1319     $owner_id = $e->requestor->id; # XXX add support for viewing other's queues?
1320     my $queues;
1321     $filters ||= {};
1322     my $search = {owner => $owner_id};
1323     $search->{$_} = $filters->{$_} for keys %$filters;
1324
1325     if($self->{record_type} eq 'bib') {
1326         $queues = $e->search_vandelay_bib_queue(
1327             [$search, {order_by => {vbq => 'evergreen.lowercase(name)'}}]);
1328     } else {
1329         $queues = $e->search_vandelay_authority_queue(
1330             [$search, {order_by => {vaq => 'evergreen.lowercase(name)'}}]);
1331     }
1332     $conn->respond($_) for @$queues;
1333     $e->rollback;
1334     return undef;
1335 }
1336
1337 __PACKAGE__->register_method(
1338     api_name    => "open-ils.vandelay.bib_queue.delete",
1339     method      => "delete_queue",
1340     api_level   => 1,
1341     argc        => 2,
1342     record_type => 'bib'
1343 );
1344 __PACKAGE__->register_method(
1345     api_name    => "open-ils.vandelay.auth_queue.delete",
1346     method      => "delete_queue",
1347     api_level   => 1,
1348     argc        => 2,
1349     record_type => 'auth'
1350 );
1351
1352 sub delete_queue {
1353     my($self, $conn, $auth, $q_id) = @_;
1354     my $e = new_editor(xact => 1, authtoken => $auth);
1355     return $e->die_event unless $e->checkauth;
1356     if($self->{record_type} eq 'bib') {
1357         return $e->die_event unless $e->allowed('CREATE_BIB_IMPORT_QUEUE');
1358         my $queue = $e->retrieve_vandelay_bib_queue($q_id)
1359             or return $e->die_event;
1360         $e->delete_vandelay_bib_queue($queue)
1361             or return $e->die_event;
1362     } else {
1363            return $e->die_event unless $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE');
1364         my $queue = $e->retrieve_vandelay_authority_queue($q_id)
1365             or return $e->die_event;
1366         $e->delete_vandelay_authority_queue($queue)
1367             or return $e->die_event;
1368     }
1369     $e->commit;
1370     return 1;
1371 }
1372
1373
1374 __PACKAGE__->register_method(
1375     api_name    => "open-ils.vandelay.queued_bib_record.html",
1376     method      => 'queued_record_html',
1377     api_level   => 1,
1378     argc        => 2,
1379     stream      => 1,
1380     record_type => 'bib'
1381 );
1382 __PACKAGE__->register_method(
1383     api_name    => "open-ils.vandelay.queued_authority_record.html",
1384     method      => 'queued_record_html',
1385     api_level   => 1,
1386     argc        => 2,
1387     stream      => 1,
1388     record_type => 'auth'
1389 );
1390
1391 sub queued_record_html {
1392     my($self, $conn, $auth, $rec_id) = @_;
1393     my $e = new_editor(xact=>1,authtoken => $auth);
1394     return $e->die_event unless $e->checkauth;
1395     my $rec;
1396     if($self->{record_type} eq 'bib') {
1397         $rec = $e->retrieve_vandelay_queued_bib_record($rec_id)
1398             or return $e->die_event;
1399     } else {
1400         $rec = $e->retrieve_vandelay_queued_authority_record($rec_id)
1401             or return $e->die_event;
1402     }
1403
1404     $e->rollback;
1405     return $U->simplereq(
1406         'open-ils.search',
1407         'open-ils.search.biblio.record.html', undef, 1, $rec->marc);
1408 }
1409
1410
1411 __PACKAGE__->register_method(
1412     api_name    => "open-ils.vandelay.bib_queue.summary.retrieve",
1413     method      => 'retrieve_queue_summary',
1414     api_level   => 1,
1415     argc        => 2,
1416     stream      => 1,
1417     record_type => 'bib'
1418 );
1419 __PACKAGE__->register_method(
1420     api_name    => "open-ils.vandelay.auth_queue.summary.retrieve",
1421     method      => 'retrieve_queue_summary',
1422     api_level   => 1,
1423     argc        => 2,
1424     stream      => 1,
1425     record_type => 'auth'
1426 );
1427
1428 sub retrieve_queue_summary {
1429     my($self, $conn, $auth, $queue_id) = @_;
1430     my $e = new_editor(xact=>1, authtoken => $auth);
1431     return $e->die_event unless $e->checkauth;
1432
1433     my $queue;
1434     my $type = $self->{record_type};
1435     if($type eq 'bib') {
1436         $queue = $e->retrieve_vandelay_bib_queue($queue_id)
1437             or return $e->die_event;
1438     } else {
1439         $queue = $e->retrieve_vandelay_authority_queue($queue_id)
1440             or return $e->die_event;
1441     }
1442
1443     my $evt = check_queue_perms($e, $type, $queue);
1444     return $evt if $evt;
1445
1446     my $search = 'search_vandelay_queued_bib_record';
1447     $search =~ s/bib/authority/ if $type ne 'bib';
1448
1449     my $summary = {
1450         queue => $queue,
1451         total => scalar(@{$e->$search({queue => $queue_id}, {idlist=>1})}),
1452         imported => scalar(@{$e->$search({queue => $queue_id, import_time => {'!=' => undef}}, {idlist=>1})}),
1453     };
1454
1455     my $class = ($type eq 'bib') ? 'vqbr' : 'vqar';
1456     $summary->{rec_import_errors} = $e->json_query({
1457         select => {$class => [{alias => 'count', column => 'id', transform => 'count', aggregate => 1}]},
1458         from => $class,
1459         where => {queue => $queue_id, import_error => {'!=' => undef}}
1460     })->[0]->{count};
1461
1462     if($type eq 'bib') {
1463
1464         # count of all items attached to records in the queue in question
1465         my $query = {
1466             select => {vii => [{alias => 'count', column => 'id', transform => 'count', aggregate => 1}]},
1467             from => 'vii',
1468             where => {
1469                 record => {
1470                     in => {
1471                         select => {vqbr => ['id']},
1472                         from => 'vqbr',
1473                         where => {queue => $queue_id}
1474                     }
1475                 }
1476             }
1477         };
1478         $summary->{total_items} = $e->json_query($query)->[0]->{count};
1479
1480         # count of items we attempted to import, but errored, attached to records in the queue in question
1481         $query->{where}->{import_error} = {'!=' => undef};
1482         $summary->{item_import_errors} = $e->json_query($query)->[0]->{count};
1483
1484         # count of items we successfully imported attached to records in the queue in question
1485         delete $query->{where}->{import_error};
1486         $query->{where}->{import_time} = {'!=' => undef};
1487         $summary->{total_items_imported} = $e->json_query($query)->[0]->{count};
1488     }
1489
1490     return $summary;
1491 }
1492
1493 # --------------------------------------------------------------------------------
1494 # Given a list of queued record IDs, imports all items attached to those records
1495 # --------------------------------------------------------------------------------
1496 sub import_record_asset_list_impl {
1497     my($conn, $rec_ids, $requestor) = @_;
1498
1499     my $roe = new_editor(xact=> 1, requestor => $requestor);
1500
1501     # for speed, filter out any records have not been
1502     # imported or have no import items to load
1503     $rec_ids = $roe->json_query({
1504         select => {vqbr => ['id']},
1505         from => {vqbr => 'vii'},
1506         where => {'+vqbr' => {
1507             id => $rec_ids,
1508             import_time => {'!=' => undef}
1509         }},
1510         distinct => 1
1511     });
1512     $rec_ids = [map {$_->{id}} @$rec_ids];
1513
1514     my $report_args = {
1515         conn => $conn,
1516         total => scalar(@$rec_ids),
1517         step => 1, # how often to respond
1518         progress => 1,
1519         in_count => 0,
1520     };
1521
1522     for my $rec_id (@$rec_ids) {
1523         my $rec = $roe->retrieve_vandelay_queued_bib_record($rec_id);
1524         my $item_ids = $roe->search_vandelay_import_item(
1525             {record => $rec->id, import_error => undef},
1526             {idlist=>1}
1527         );
1528
1529         for my $item_id (@$item_ids) {
1530             my $e = new_editor(requestor => $requestor, xact => 1);
1531             my $item = $e->retrieve_vandelay_import_item($item_id);
1532             $$report_args{import_item} = $item;
1533             $$report_args{e} = $e;
1534             $$report_args{import_error} = undef;
1535             $$report_args{evt} = undef;
1536
1537             # --------------------------------------------------------------------------------
1538             # Find or create the volume
1539             # --------------------------------------------------------------------------------
1540             my ($vol, $evt) =
1541                 OpenILS::Application::Cat::AssetCommon->find_or_create_volume(
1542                     $e, $item->call_number, $rec->imported_as, $item->owning_lib);
1543
1544             if($evt) {
1545
1546                 $$report_args{evt} = $evt;
1547                 respond_with_status($report_args);
1548                 next;
1549             }
1550
1551             # --------------------------------------------------------------------------------
1552             # Create the new copy
1553             # --------------------------------------------------------------------------------
1554             my $copy = Fieldmapper::asset::copy->new;
1555             $copy->loan_duration(2);
1556             $copy->fine_level(2);
1557             $copy->barcode($item->barcode);
1558             $copy->location($item->location);
1559             $copy->circ_lib($item->circ_lib || $item->owning_lib);
1560             $copy->status( defined($item->status) ? $item->status : OILS_COPY_STATUS_IN_PROCESS );
1561             $copy->circulate($item->circulate);
1562             $copy->deposit($item->deposit);
1563             $copy->deposit_amount($item->deposit_amount);
1564             $copy->ref($item->ref);
1565             $copy->holdable($item->holdable);
1566             $copy->price($item->price);
1567             $copy->circ_as_type($item->circ_as_type);
1568             $copy->alert_message($item->alert_message);
1569             $copy->opac_visible($item->opac_visible);
1570             $copy->circ_modifier($item->circ_modifier);
1571
1572             # --------------------------------------------------------------------------------
1573             # Check for dupe barcode
1574             # --------------------------------------------------------------------------------
1575             if($evt = OpenILS::Application::Cat::AssetCommon->create_copy($e, $vol, $copy)) {
1576                 $$report_args{evt} = $evt;
1577                 $$report_args{import_error} = 'import.item.duplicate.barcode'
1578                     if $evt->{textcode} eq 'ITEM_BARCODE_EXISTS';
1579                 respond_with_status($report_args);
1580                 next;
1581             }
1582
1583             # --------------------------------------------------------------------------------
1584             # create copy notes
1585             # --------------------------------------------------------------------------------
1586             $evt = OpenILS::Application::Cat::AssetCommon->create_copy_note(
1587                 $e, $copy, '', $item->pub_note, 1) if $item->pub_note;
1588
1589             if($evt) {
1590                 $$report_args{evt} = $evt;
1591                 respond_with_status($report_args);
1592                 next;
1593             }
1594
1595             $evt = OpenILS::Application::Cat::AssetCommon->create_copy_note(
1596                 $e, $copy, '', $item->priv_note) if $item->priv_note;
1597
1598             if($evt) {
1599                 $$report_args{evt} = $evt;
1600                 respond_with_status($report_args);
1601                 next;
1602             }
1603
1604             # set the import data on the import item
1605             $item->imported_as($copy->id); # $copy->id is set by create_copy() ^--
1606             $item->import_time('now');
1607
1608             unless($e->update_vandelay_import_item($item)) {
1609                 $$report_args{evt} = $e->die_event;
1610                 respond_with_status($report_args);
1611                 next;
1612             }
1613
1614             # --------------------------------------------------------------------------------
1615             # Item import succeeded
1616             # --------------------------------------------------------------------------------
1617             $e->commit;
1618             $$report_args{in_count}++;
1619             respond_with_status($report_args);
1620             $logger->info("vl: successfully imported item " . $item->barcode);
1621         }
1622
1623     }
1624
1625     $roe->rollback;
1626     return undef;
1627 }
1628
1629
1630 sub respond_with_status {
1631     my $args = shift;
1632     my $e = $$args{e};
1633
1634     #  If the import failed, track the failure reason
1635
1636     my $error = $$args{import_error};
1637     my $evt = $$args{evt};
1638
1639     if($error or $evt) {
1640
1641         my $item = $$args{import_item};
1642         $logger->info("vl: unable to import item " . $item->barcode);
1643
1644         $error ||= 'general.unknown';
1645         $item->import_error($error);
1646
1647         if($evt) {
1648             my $detail = sprintf("%s : %s", $evt->{textcode}, substr($evt->{desc}, 0, 140));
1649             $item->error_detail($detail);
1650         }
1651
1652         # state of the editor is unknown at this point.  Force a rollback and start over.
1653         $e->rollback;
1654         $e = new_editor(xact => 1);
1655         $e->update_vandelay_import_item($item);
1656         $e->commit;
1657     }
1658
1659     if($$args{report_all} or ($$args{progress} % $$args{step}) == 0) {
1660         $$args{conn}->respond({
1661             total => $$args{total},
1662             progress => $$args{progress},
1663             success_count => $$args{success_count},
1664             err_event => $evt
1665         });
1666         $$args{step} *= 2 unless $$args{step} == 256;
1667     }
1668
1669     $$args{progress}++;
1670 }
1671
1672 __PACKAGE__->register_method(
1673     api_name    => "open-ils.vandelay.match_set.get_tree",
1674     method      => "match_set_get_tree",
1675     api_level   => 1,
1676     argc        => 2,
1677     signature   => {
1678         desc    => q/For a given vms object, return a tree of match set points
1679                     represented by a vmsp object with recursively fleshed
1680                     children./
1681     }
1682 );
1683
1684 sub match_set_get_tree {
1685     my ($self, $conn, $authtoken, $match_set_id) = @_;
1686
1687     $match_set_id = int($match_set_id) or return;
1688
1689     my $e = new_editor("authtoken" => $authtoken);
1690     $e->checkauth or return $e->die_event;
1691
1692     my $set = $e->retrieve_vandelay_match_set($match_set_id) or
1693         return $e->die_event;
1694
1695     $e->allowed("ADMIN_IMPORT_MATCH_SET", $set->owner) or
1696         return $e->die_event;
1697
1698     my $tree = $e->search_vandelay_match_set_point([
1699         {"match_set" => $match_set_id, "parent" => undef},
1700         {"flesh" => -1, "flesh_fields" => {"vmsp" => ["children"]}}
1701     ]) or return $e->die_event;
1702
1703     return pop @$tree;
1704 }
1705
1706
1707 __PACKAGE__->register_method(
1708     api_name    => "open-ils.vandelay.match_set.update",
1709     method      => "match_set_update_tree",
1710     api_level   => 1,
1711     argc        => 3,
1712     signature   => {
1713         desc => q/Replace any vmsp objects associated with a given (by ID) vms
1714                 with the given objects (recursively fleshed vmsp tree)./
1715     }
1716 );
1717
1718 sub _walk_new_vmsp {
1719     my ($e, $match_set_id, $node, $parent_id) = @_;
1720
1721     my $point = new Fieldmapper::vandelay::match_set_point;
1722     $point->parent($parent_id);
1723     $point->match_set($match_set_id);
1724     $point->$_($node->$_) for (qw/bool_op svf tag subfield negate quality/);
1725
1726     $e->create_vandelay_match_set_point($point) or return $e->die_event;
1727
1728     $parent_id = $e->data->id;
1729     if ($node->children && @{$node->children}) {
1730         for (@{$node->children}) {
1731             return $e->die_event if
1732                 _walk_new_vmsp($e, $match_set_id, $_, $parent_id);
1733         }
1734     }
1735
1736     return;
1737 }
1738
1739 sub match_set_update_tree {
1740     my ($self, $conn, $authtoken, $match_set_id, $tree) = @_;
1741
1742     my $e = new_editor("xact" => 1, "authtoken" => $authtoken);
1743     $e->checkauth or return $e->die_event;
1744
1745     my $set = $e->retrieve_vandelay_match_set($match_set_id) or
1746         return $e->die_event;
1747
1748     $e->allowed("ADMIN_IMPORT_MATCH_SET", $set->owner) or
1749         return $e->die_event;
1750
1751     my $existing = $e->search_vandelay_match_set_point([
1752         {"match_set" => $match_set_id},
1753         {"order_by" => {"vmsp" => "id DESC"}}
1754     ]) or return $e->die_event;
1755
1756     # delete points, working up from leaf points to the root
1757     while(@$existing) {
1758         for my $point (shift @$existing) {
1759             if( grep {$_->parent eq $point->id} @$existing) {
1760                 push(@$existing, $point);
1761             } else {
1762                 $e->delete_vandelay_match_set_point($point) or return $e->die_event;
1763             }
1764         }
1765     }
1766
1767     _walk_new_vmsp($e, $match_set_id, $tree);
1768
1769     $e->commit or return $e->die_event;
1770 }
1771
1772 __PACKAGE__->register_method(
1773     api_name    => 'open-ils.vandelay.bib_queue.to_bucket',
1774     method      => 'bib_queue_to_bucket',
1775     api_level   => 1,
1776     argc        => 2,
1777     signature   => {
1778         desc    => q/Add to or create a new bib container (bucket) with the successfully
1779                     imported contents of a vandelay queue.  Any user that has Vandelay
1780                     queue create permissions can append or create buckets from his-her own queues./,
1781         params  => [
1782             {desc => 'Authtoken', type => 'string'},
1783             {desc => 'Queue ID', type => 'number'},
1784             {desc => 'Bucket Name', type => 'string'}
1785         ],
1786         return  => {desc => q/
1787             {bucket => $bucket, addcount => number-of-items-added-to-bucket, item_count => total-bucket-item-count} on success,
1788             {add_count => 0} if there is nothing to do, and Event on error/}
1789     }
1790 );
1791
1792 sub bib_queue_to_bucket {
1793     my ($self, $conn, $auth, $q_id, $bucket_name) = @_;
1794
1795     my $e = new_editor(xact => 1, authtoken => $auth);
1796     return $e->die_event unless $e->checkauth;
1797
1798     my $queue = $e->retrieve_vandelay_bib_queue($q_id)
1799         or return $e->die_event;
1800
1801     return OpenILS::Event->new('BAD_PARAMS',
1802         note => q/Bucket creator must be queue owner/)
1803         unless $queue->owner == $e->requestor->id;
1804
1805     # find the bib IDs that will go into the bucket
1806     my $bib_ids = $e->json_query({
1807         select => {vqbr => ['imported_as']},
1808         from => 'vqbr',
1809         where => {queue => $q_id, imported_as => {'!=' => undef}}
1810     });
1811
1812     if (!@$bib_ids) { # no records to add
1813         $e->rollback;
1814         return {add_count => 0};
1815     }
1816
1817     # allow user to add to an existing bucket by name
1818     my $bucket = $e->search_container_biblio_record_entry_bucket({
1819         owner => $e->requestor->id,
1820         name => $bucket_name,
1821         btype => 'vandelay_queue'
1822     })->[0];
1823
1824     # if the bucket does not exist, create a new one
1825     if (!$bucket) {
1826         $bucket = Fieldmapper::container::biblio_record_entry_bucket->new;
1827         $bucket->name($bucket_name);
1828         $bucket->owner($e->requestor->id);
1829         $bucket->btype('vandelay_queue');
1830
1831         $e->create_container_biblio_record_entry_bucket($bucket)
1832             or return $e->die_event;
1833     }
1834
1835     # create the new bucket items
1836     for my $bib_id ( map {$_->{imported_as}} @$bib_ids ) {
1837         my $item = Fieldmapper::container::biblio_record_entry_bucket_item->new;
1838         $item->target_biblio_record_entry($bib_id);
1839         $item->bucket($bucket->id);
1840         $e->create_container_biblio_record_entry_bucket_item($item)
1841             or return $e->die_event;
1842     }
1843
1844     # re-fetch the bucket to pick up the correct create_time
1845     $bucket = $e->retrieve_container_biblio_record_entry_bucket($bucket->id)
1846         or return $e->die_event;
1847
1848     # get the total count of items in this bucket
1849     my $count = $e->json_query({
1850         select => {cbrebi => [{
1851             aggregate =>  1,
1852             transform => 'count',
1853             alias => 'count',
1854             column => 'id'
1855         }]},
1856         from => 'cbrebi',
1857         where => {bucket => $bucket->id}
1858     })->[0];
1859
1860     $e->commit;
1861
1862     return {
1863         bucket => $bucket,
1864         add_count => scalar(@$bib_ids), # items added to the bucket
1865         item_count => $count->{count} # total items in buckets
1866     };
1867 }
1868
1869 1;