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
  27 sub initialize {}
  28 sub child_init {}
  29
  30 sub entityize {
  31         my $self = shift;
  32         my $stuff = shift;
  33         my $form = shift;
  34
  35         if ($form eq 'D') {
  36                 $stuff = NFD($stuff);
  37         } else {
  38                 $stuff = NFC($stuff);
  39         }
  40
  41         $stuff =~ s/([\x{0080}-\x{fffd}])/sprintf('&#x%X;',ord($1))/sgoe;
  42         return $stuff;
  43 }
  44
  45 # --------------------------------------------------------------------------------
  46 # Biblio ingest
  47
  48 sub create_bib_queue {
  49         my $self = shift;
  50         my $client = shift;
  51         my $auth = shift;
  52         my $name = shift;
  53         my $owner = shift;
  54         my $type = shift;
  55
  56         my $e = new_editor(authtoken => $auth, xact => 1);
  57
  58         return $e->die_event unless $e->checkauth;
  59         return $e->die_event unless $e->allowed('CREATE_BIB_IMPORT_QUEUE', $owner);
  60     $owner ||= $e->requestor->id;
  61
  62         my $queue = new Fieldmapper::vandelay::bib_queue();
  63         $queue->name( $name );
  64         $queue->owner( $owner );
  65         $queue->queue_type( $type ) if ($type);
  66
  67         my $new_q = $e->create_vandelay_bib_queue( $queue );
  68         return $e->die_event unless ($new_q);
  69         $e->commit;
  70
  71     return $new_q;
  72 }
  73 __PACKAGE__->register_method(
  74         api_name        => "open-ils.vandelay.bib_queue.create",
  75         method          => "create_bib_queue",
  76         api_level       => 1,
  77         argc            => 3,
  78 );
  79
  80
  81 sub create_auth_queue {
  82         my $self = shift;
  83         my $client = shift;
  84         my $auth = shift;
  85         my $name = shift;
  86         my $owner = shift;
  87         my $type = shift;
  88
  89         my $e = new_editor(authtoken => $auth, xact => 1);
  90
  91         return $e->die_event unless $e->checkauth;
  92         return $e->die_event unless $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE', $owner);
  93     $owner ||= $e->requestor->id;
  94
  95         my $queue = new Fieldmapper::vandelay::authority_queue();
  96         $queue->name( $name );
  97         $queue->owner( $owner );
  98         $queue->queue_type( $type ) if ($type);
  99
 100         my $new_q = $e->create_vandelay_authority_queue( $queue );
 101         $e->die_event unless ($new_q);
 102         $e->commit;
 103
 104     return $new_q;
 105 }
 106 __PACKAGE__->register_method(
 107         api_name        => "open-ils.vandelay.authority_queue.create",
 108         method          => "create_auth_queue",
 109         api_level       => 1,
 110         argc            => 3,
 111 );
 112
 113 sub add_record_to_bib_queue {
 114         my $self = shift;
 115         my $client = shift;
 116         my $auth = shift;
 117         my $queue = shift;
 118         my $marc = shift;
 119         my $purpose = shift;
 120
 121         my $e = new_editor(authtoken => $auth, xact => 1);
 122
 123         $queue = $e->retrieve_vandelay_bib_queue($queue);
 124
 125         return $e->die_event unless $e->checkauth;
 126         return $e->die_event unless
 127                 ($e->allowed('CREATE_BIB_IMPORT_QUEUE', undef, $queue) ||
 128                  $e->allowed('CREATE_BIB_IMPORT_QUEUE', $queue->owner));
 129
 130         my $new_rec = _add_bib_rec($e, $marc, $queue->id, $purpose);
 131
 132         return $e->die_event unless ($new_rec);
 133         $e->commit;
 134     return $new_rec;
 135 }
 136 __PACKAGE__->register_method(
 137         api_name        => "open-ils.vandelay.queued_bib_record.create",
 138         method          => "add_record_to_bib_queue",
 139         api_level       => 1,
 140         argc            => 3,
 141 );
 142
 143 sub _add_bib_rec {
 144         my $e = shift;
 145         my $marc = shift;
 146         my $queue = shift;
 147         my $purpose = shift;
 148
 149         my $rec = new Fieldmapper::vandelay::queued_bib_record();
 150         $rec->marc( $marc );
 151         $rec->queue( $queue );
 152         $rec->purpose( $purpose ) if ($purpose);
 153
 154         return $e->create_vandelay_queued_bib_record( $rec );
 155 }
 156
 157 sub add_record_to_authority_queue {
 158         my $self = shift;
 159         my $client = shift;
 160         my $auth = shift;
 161         my $queue = shift;
 162         my $marc = shift;
 163         my $purpose = shift;
 164
 165         my $e = new_editor(authtoken => $auth, xact => 1);
 166
 167         $queue = $e->retrieve_vandelay_authority_queue($queue);
 168
 169         return $e->die_event unless $e->checkauth;
 170         return $e->die_event unless
 171                 ($e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE', undef, $queue) ||
 172                  $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE', $queue->owner));
 173
 174         my $new_rec = _add_auth_rec($e, $marc, $queue->id, $purpose);
 175
 176         return $e->die_event unless ($new_rec);
 177         $e->commit;
 178     return $new_rec;
 179 }
 180 __PACKAGE__->register_method(
 181         api_name        => "open-ils.vandelay.queued_authority_record.create",
 182         method          => "add_record_to_authority_queue",
 183         api_level       => 1,
 184         argc            => 3,
 185 );
 186
 187 sub _add_auth_rec {
 188         my $e = shift;
 189         my $marc = shift;
 190         my $queue = shift;
 191     my $purpose = shift;
 192
 193         my $rec = new Fieldmapper::vandelay::queued_authority_record();
 194         $rec->marc( $marc );
 195         $rec->queue( $queue );
 196         $rec->purpose( $purpose ) if ($purpose);
 197
 198         return $e->create_vandelay_queued_authority_record( $rec );
 199 }
 200
 201 sub process_spool {
 202         my $self = shift;
 203         my $client = shift;
 204         my $auth = shift;
 205         my $fingerprint = shift;
 206         my $queue = shift;
 207
 208         my $e = new_editor(authtoken => $auth, xact => 1);
 209
 210     my $type = ($self->api_name =~ /auth/) ? 'auth' : 'bib';
 211
 212         if ($type eq 'bib') {
 213                 return $e->die_event unless $e->checkauth;
 214                 return $e->die_event unless
 215                         ($e->allowed('CREATE_BIB_IMPORT_QUEUE', undef, $queue) ||
 216                          $e->allowed('CREATE_BIB_IMPORT_QUEUE', $queue->owner));
 217         } else {
 218                 return $e->die_event unless $e->checkauth;
 219                 return $e->die_event unless
 220                         ($e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE', undef, $queue) ||
 221                          $e->allowed('CREATE_AUTHORITY_IMPORT_QUEUE', $queue->owner));
 222         }
 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 = $self->entityize($xml);
 251                         $xml =~ s/[\x00-\x1f]//go;
 252
 253                         if ($self->{record_type} eq 'bib') {
 254                                 _add_bib_rec( $e, $xml, $queue, $purpose ) or return $e->die_event;
 255                         } else {
 256                                 _add_auth_rec( $e, $xml, $queue, $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
 287 1;
 288