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