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

   1 package OpenILS::Application::Vandelay;
   2 use strict; use warnings;
   3 use OpenILS::Application;
   4 use base qw/OpenILS::Application/;
   5
   6 use Unicode::Normalize;
   7 use OpenSRF::EX qw/:try/;
   8
   9 use OpenSRF::AppSession;
  10 use OpenSRF::Utils::SettingsClient;
  11 use OpenSRF::Utils::Cache;
  12
  13 use OpenILS::Utils::Fieldmapper;
  14 use OpenILS::Utils::CStoreEditor qw/:funcs/;
  15
  16 use MARC::Batch;
  17 use MARC::Record;
  18 use MARC::File::XML;
  19
  20 use OpenILS::Utils::Fieldmapper;
  21
  22 use Time::HiRes qw(time);
  23
  24 use OpenSRF::Utils::Logger qw/$logger/;
  25 use MIME::Base64;
  26 use OpenILS::Application::AppUtils;
  27 my $U = 'OpenILS::Application::AppUtils';
  28
  29 sub initialize {}
  30 sub child_init {}
  31
  32 sub entityize {
  33         my $stuff = shift;
  34         my $form = shift;
  35
  36         if ($form eq 'D') {
  37                 $stuff = NFD($stuff);
  38         } else {
  39                 $stuff = NFC($stuff);
  40         }
  41
  42         $stuff =~ s/([\x{0080}-\x{fffd}])/sprintf('&#x%X;',ord($1))/sgoe;
  43         return $stuff;
  44 }
  45
  46 # --------------------------------------------------------------------------------
  47 # Biblio ingest
  48
  49 sub create_bib_queue {
  50         my $self = shift;
  51         my $client = shift;
  52         my $auth = shift;
  53         my $name = shift;
  54         my $owner = shift;
  55         my $type = shift;
  56
  57         my $e = new_editor(authtoken => $auth, xact => 1);
  58
  59         return $e->die_event unless $e->checkauth;
  60         return $e->die_event unless $e->allowed('CREATE_BIB_IMPORT_QUEUE');
  61     $owner ||= $e->requestor->id;
  62
  63         my $queue = new Fieldmapper::vandelay::bib_queue();
  64         $queue->name( $name );
  65         $queue->owner( $owner );
  66         $queue->queue_type( $type ) if ($type);
  67
  68         my $new_q = $e->create_vandelay_bib_queue( $queue );
  69         return $e->die_event unless ($new_q);
  70         $e->commit;
  71
  72     return $new_q;
  73 }
  74 __PACKAGE__->register_method(
  75         api_name        => "open-ils.vandelay.bib_queue.create",
  76         method          => "create_bib_queue",
  77         api_level       => 1,
  78         argc            => 3,
  79 );
  80
  81
  82 sub create_auth_queue {
  83         my $self = shift;
  84         my $client = shift;
  85         my $auth = shift;
  86         my $name = shift;
  87         my $owner = shift;
  88         my $type = shift;
  89
  90         my $e = new_editor(authtoken => $auth, xact => 1);
  91
  92         return $e->die_event unless $e->checkauth;
  93         return $e->die_event unless $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE');
  94     $owner ||= $e->requestor->id;
  95
  96         my $queue = new Fieldmapper::vandelay::authority_queue();
  97         $queue->name( $name );
  98         $queue->owner( $owner );
  99         $queue->queue_type( $type ) if ($type);
 100
 101         my $new_q = $e->create_vandelay_authority_queue( $queue );
 102         $e->die_event unless ($new_q);
 103         $e->commit;
 104
 105     return $new_q;
 106 }
 107 __PACKAGE__->register_method(
 108         api_name        => "open-ils.vandelay.authority_queue.create",
 109         method          => "create_auth_queue",
 110         api_level       => 1,
 111         argc            => 3,
 112 );
 113
 114 sub add_record_to_bib_queue {
 115         my $self = shift;
 116         my $client = shift;
 117         my $auth = shift;
 118         my $queue = shift;
 119         my $marc = shift;
 120         my $purpose = shift;
 121
 122         my $e = new_editor(authtoken => $auth, xact => 1);
 123
 124         $queue = $e->retrieve_vandelay_bib_queue($queue);
 125
 126         return $e->die_event unless $e->checkauth;
 127         return $e->die_event unless
 128                 ($e->allowed('CREATE_BIB_IMPORT_QUEUE', undef, $queue) ||
 129                  $e->allowed('CREATE_BIB_IMPORT_QUEUE'));
 130
 131         my $new_rec = _add_bib_rec($e, $marc, $queue->id, $purpose);
 132
 133         return $e->die_event unless ($new_rec);
 134         $e->commit;
 135     return $new_rec;
 136 }
 137 __PACKAGE__->register_method(
 138         api_name        => "open-ils.vandelay.queued_bib_record.create",
 139         method          => "add_record_to_bib_queue",
 140         api_level       => 1,
 141         argc            => 3,
 142 );
 143
 144 sub _add_bib_rec {
 145         my $e = shift;
 146         my $marc = shift;
 147         my $queue = shift;
 148         my $purpose = shift;
 149
 150         my $rec = new Fieldmapper::vandelay::queued_bib_record();
 151         $rec->marc( $marc );
 152         $rec->queue( $queue );
 153         $rec->purpose( $purpose ) if ($purpose);
 154
 155         return $e->create_vandelay_queued_bib_record( $rec );
 156 }
 157
 158 sub add_record_to_authority_queue {
 159         my $self = shift;
 160         my $client = shift;
 161         my $auth = shift;
 162         my $queue = shift;
 163         my $marc = shift;
 164         my $purpose = shift;
 165
 166         my $e = new_editor(authtoken => $auth, xact => 1);
 167
 168         $queue = $e->retrieve_vandelay_authority_queue($queue);
 169
 170         return $e->die_event unless $e->checkauth;
 171         return $e->die_event unless
 172                 ($e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE', undef, $queue) ||
 173                  $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE'));
 174
 175         my $new_rec = _add_auth_rec($e, $marc, $queue->id, $purpose);
 176
 177         return $e->die_event unless ($new_rec);
 178         $e->commit;
 179     return $new_rec;
 180 }
 181 __PACKAGE__->register_method(
 182         api_name        => "open-ils.vandelay.queued_authority_record.create",
 183         method          => "add_record_to_authority_queue",
 184         api_level       => 1,
 185         argc            => 3,
 186 );
 187
 188 sub _add_auth_rec {
 189         my $e = shift;
 190         my $marc = shift;
 191         my $queue = shift;
 192     my $purpose = shift;
 193
 194         my $rec = new Fieldmapper::vandelay::queued_authority_record();
 195         $rec->marc( $marc );
 196         $rec->queue( $queue );
 197         $rec->purpose( $purpose ) if ($purpose);
 198
 199         return $e->create_vandelay_queued_authority_record( $rec );
 200 }
 201
 202 sub process_spool {
 203         my $self = shift;
 204         my $client = shift;
 205         my $auth = shift;
 206         my $fingerprint = shift;
 207         my $queue_id = shift;
 208
 209         my $e = new_editor(authtoken => $auth, xact => 1);
 210     return $e->die_event unless $e->checkauth;
 211
 212     my $queue;
 213     my $type = $self->{record_type};
 214
 215     if($type eq 'bib') {
 216         $queue = $e->retrieve_vandelay_bib_queue($queue_id) or return $e->die_event;
 217     } else {
 218         $queue = $e->retrieve_vandelay_authority_queue($queue_id) or return $e->die_event;
 219     }
 220
 221     my $evt = check_queue_perms($e, $type, $queue);
 222     return $evt if $evt;
 223
 224         my $method = "open-ils.vandelay.queued_${type}_record.create";
 225         $method = $self->method_lookup( $method );
 226
 227     my $cache = new OpenSRF::Utils::Cache();
 228
 229     my $data = $cache->get_cache('vandelay_import_spool_' . $fingerprint);
 230         my $purpose = $data->{purpose};
 231     $data = decode_base64($data->{marc});
 232
 233     $logger->info("vandelay loaded $fingerprint purpose=$purpose and ".length($data)." bytes of data");
 234
 235     my $fh;
 236     open $fh, '<', \$data;
 237
 238     my $marctype = 'USMARC'; # ?
 239         my $batch = new MARC::Batch ( $marctype, $fh );
 240         $batch->strict_off;
 241
 242         my $count = 0;
 243         while (my $r = $batch->next) {
 244         $logger->info("processing record $count");
 245                 try {
 246                         (my $xml = $r->as_xml_record()) =~ s/\n//sog;
 247                         $xml =~ s/^<\?xml.+\?\s*>//go;
 248                         $xml =~ s/>\s+</></go;
 249                         $xml =~ s/\p{Cc}//go;
 250                         $xml = entityize($xml);
 251                         $xml =~ s/[\x00-\x1f]//go;
 252
 253                         if ($type eq 'bib') {
 254                                 _add_bib_rec( $e, $xml, $queue_id, $purpose ) or return $e->die_event;
 255                         } else {
 256                                 _add_auth_rec( $e, $xml, $queue_id, $purpose ) or return $e->die_event;
 257                         }
 258                         $count++;
 259
 260                         $client->respond( $count );
 261                 } catch Error with {
 262                         my $error = shift;
 263                         $logger->warn("Encountered a bad record at Vandelay ingest: ".$error);
 264                 }
 265         }
 266
 267         $e->commit;
 268         return undef;
 269 }
 270 __PACKAGE__->register_method(
 271         api_name        => "open-ils.vandelay.bib.process_spool",
 272         method          => "process_spool",
 273         api_level       => 1,
 274         argc            => 3,
 275         record_type     => 'bib'
 276 );
 277 __PACKAGE__->register_method(
 278         api_name        => "open-ils.vandelay.auth.process_spool",
 279         method          => "process_spool",
 280         api_level       => 1,
 281         argc            => 3,
 282         record_type     => 'auth'
 283 );
 284
 285
 286 __PACKAGE__->register_method(
 287         api_name        => "open-ils.vandelay.bib_queue.records.retrieve",
 288         method          => 'retrieve_queue',
 289         api_level       => 1,
 290         argc            => 2,
 291     stream      => 1,
 292         record_type     => 'bib'
 293 );
 294 __PACKAGE__->register_method(
 295         api_name        => "open-ils.vandelay.auth_queue.records.retrieve",
 296         method          => 'retrieve_queue',
 297         api_level       => 1,
 298         argc            => 2,
 299     stream      => 1,
 300         record_type     => 'auth'
 301 );
 302
 303 sub retrieve_queue {
 304     my($self, $conn, $auth, $queue_id, $options) = @_;
 305     my $e = new_editor(authtoken => $auth);
 306     return $e->event unless $e->checkauth;
 307
 308     my $type = $self->{record_type};
 309     my $queue;
 310     if($type eq 'bib') {
 311         $queue = $e->retrieve_vandelay_bib_queue($queue_id) or return $e->die_event;
 312     } else {
 313         $queue = $e->retrieve_vandelay_authority_queue($queue_id) or return $e->die_event;
 314     }
 315     my $evt = check_queue_perms($e, $type, $queue);
 316     return $evt if $evt;
 317
 318     my $class = ($type eq 'bib') ? 'vqbr' : 'vqar';
 319     my $search = ($type eq 'bib') ? 'search_vandelay_queued_bib_record' : 'search_vandelay_queued_authority_record';
 320     my $retrieve = ($type eq 'bib') ? 'retrieve_vandelay_queued_bib_record' : 'retrieve_vandelay_queued_authority_record';
 321     my $record_ids = $e->$search({queue => $queue_id}, {idlist => 1});
 322
 323     for my $rec_id (@$record_ids) {
 324         my $rec = $e->$retrieve([
 325             $rec_id,
 326             {   flesh => 1,
 327                 flesh_fields => {$class => ['attributes', 'matches']}
 328             }
 329         ]);
 330         $rec->clear_marc if $$options{clear_marc};
 331         $conn->respond($rec);
 332     }
 333     return undef;
 334 }
 335
 336 sub check_queue_perms {
 337     my($e, $type, $queue) = @_;
 338         if ($type eq 'bib') {
 339                 return $e->die_event unless
 340                         ($e->allowed('CREATE_BIB_IMPORT_QUEUE', undef, $queue) ||
 341                          $e->allowed('CREATE_BIB_IMPORT_QUEUE'));
 342         } else {
 343                 return $e->die_event unless
 344                         ($e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE', undef, $queue) ||
 345                          $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE'));
 346         }
 347
 348     return undef;
 349 }
 350
 351 __PACKAGE__->register_method(
 352         api_name        => "open-ils.vandelay.bib_record.list.import",
 353         method          => 'import_record_list',
 354         api_level       => 1,
 355         argc            => 2,
 356     stream      => 1,
 357         record_type     => 'bib'
 358 );
 359
 360 __PACKAGE__->register_method(
 361         api_name        => "open-ils.vandelay.auth_record.list.import",
 362         method          => 'import_record_list',
 363         api_level       => 1,
 364         argc            => 2,
 365     stream      => 1,
 366         record_type     => 'auth'
 367 );
 368
 369 sub import_record_list {
 370     my($self, $conn, $auth, $rec_ids) = @_;
 371     my $e = new_editor(xact => 1, authtoken => $auth);
 372     return $e->die_event unless $e->checkauth;
 373     my $err = import_record_list_impl($self, $conn, $auth, $e, $rec_ids);
 374     return $err if $err;
 375     $e->commit;
 376     return {complete => 1};
 377 }
 378
 379 sub import_record_list_impl {
 380     my($self, $conn, $auth, $e, $rec_ids) = @_;
 381
 382     my $type = $self->{record_type};
 383     my $total = @$rec_ids;
 384     my $count = 0;
 385
 386     for my $rec_id (@$rec_ids) {
 387         if($type eq 'bib') {
 388
 389             my $rec = $e->retrieve_vandelay_queued_bib_record($rec_id)
 390                 or return $e->die_event;
 391
 392             my $record = $U->simplereq(
 393                 'open-ils.cat',
 394                 'open-ils.cat.biblio.record.xml.import',
 395                 $auth, $rec->marc ); #$rec->bib_source);
 396
 397             if($U->event_code($record)) {
 398                 $e->rollback;
 399                 return $record;
 400             }
 401
 402             $rec->imported_as($record->id);
 403             $rec->import_time('now');
 404             $e->update_vandelay_queued_bib_record($rec) or return $e->die_event;
 405         }
 406
 407         $conn->respond({total => $total, progress => ++$count, imported => $rec_id});
 408     }
 409
 410     return undef;
 411 }
 412
 413
 414
 415
 416 1;