Open-ILS/src/perlmods/OpenILS/Application/Storage/Publisher/biblio.pm

   1 package OpenILS::Application::Storage::Publisher::biblio;
   2 use base qw/OpenILS::Application::Storage/;
   3 use OpenSRF::EX qw/:try/;
   4 use OpenILS::Application::Storage::CDBI::biblio;
   5 use OpenILS::Utils::Fieldmapper;
   6
   7 sub create_record_node {
   8         my $self = shift;
   9         my $client = shift;
  10         my $node = shift;;
  11
  12         try {
  13                 my $n = biblio::record_node->create($node);
  14                 $client->respond( $n->id );
  15         } catch Error with {
  16                 $client->respond( 0 );
  17         };
  18
  19         return undef;
  20 }
  21 __PACKAGE__->register_method(
  22         method          => 'create_record_node',
  23         api_name        => 'open-ils.storage.biblio.record_node.create',
  24         api_level       => 1,
  25         argc            => 1,
  26 );
  27
  28 sub update_record_node {
  29         my $self = shift;
  30         my $client = shift;
  31         my $node = shift;;
  32
  33         my $n = biblio::record_node->retrieve("$$node{id}");
  34         return undef unless ($n);
  35
  36         for my $field ( keys %$node ) {
  37                 $n->$field( $$node{$field} );
  38         }
  39
  40         try {
  41                 $n->update;
  42                 $client->respond( $n->id );
  43         } catch Error with {
  44                 $client->respond( 0 );
  45         };
  46
  47         return undef;
  48 }
  49 __PACKAGE__->register_method(
  50         method          => 'update_record_node',
  51         api_name        => 'open-ils.storage.biblio.record_node.update',
  52         api_level       => 1,
  53         argc            => 1,
  54 );
  55
  56
  57 sub create_record_nodeset {
  58         my $self = shift;
  59         my $client = shift;
  60
  61         # COPY version... not working yet
  62         if (0) {
  63
  64                 my $dbh = biblio::record_node->db_Main;
  65                 my @cols = grep { $_ ne biblio::record_node->primary } biblio::record_node->columns('All');
  66
  67                 $dbh->do('COPY '. biblio::record_node->table .' ('.join(',',@cols).')'.' FROM STDIN');
  68
  69                 while ( my $node = shift(@_) ) {
  70                         my @parts;
  71                         for my $col (@cols) {
  72                                 my $part;
  73                                 if ($part = $node->{$col}) {
  74                                         push @parts, $dbh->quote($part);
  75                                 } else {
  76                                         push @parts, '\N';
  77                                 }
  78                         }
  79                         return 0 unless ($dbh->func(join("\t", map {s/^'(.*)'$/$1/o} @parts)."\n", 'putline'));
  80                 }
  81                 $dbh->func('\.', 'putline');
  82                 return 1;
  83         } else {
  84                 # INSERT version, works but slow
  85
  86                 my $method = $self->method_lookup('open-ils.storage.biblio.record_node.create');
  87
  88                 my @ids;
  89                 my $total = scalar(@ids);
  90                 my @success;
  91
  92                 while ( my $node = shift(@_) ) {
  93                         my ($res) = $method->run( $node );
  94                         push @success, $res if ($res);
  95                 }
  96
  97                 if ($total == scalar(@success)) {
  98                         return 1;
  99                 } else {
 100                         return 0;
 101                 }
 102         }
 103 }
 104 __PACKAGE__->register_method(
 105         method          => 'create_record_nodeset',
 106         api_name        => 'open-ils.storage.biblio.record_node.batch.create',
 107         api_level       => 1,
 108         argc            => 1,
 109 );
 110
 111 sub create_record_entry {
 112         my $self = shift;
 113         my $client = shift;
 114         my $metadata = shift;
 115
 116         try {
 117                 my $rec = biblio::record_entry->create($metadata);
 118                 $client->respond( $rec->id );
 119         } catch Error with {
 120                 $client->respond( 0 );
 121         };
 122
 123         return undef;
 124 }
 125 __PACKAGE__->register_method(
 126         method          => 'create_record_entry',
 127         api_name        => 'open-ils.storage.biblio.record_entry.create',
 128         api_level       => 1,
 129         argc            => 2,
 130         note            => <<TEXT,
 131
 132 Params should be passed as a hash ref!
 133 Required fields are:
 134
 135         creator
 136         editor
 137
 138 Please at least try to fill in:
 139
 140         tcn_source
 141         tcn_value
 142         metarecord
 143         source
 144         active
 145
 146 TEXT
 147
 148 );
 149
 150 sub update_record_entry {
 151         my $self = shift;
 152         my $client = shift;
 153         my $entry = shift;
 154
 155         my $rec = biblio::record_entry->retrieve("$$entry{id}");
 156         return undef unless ($rec);
 157
 158         for my $field ( keys %$node ) {
 159                 $rec->$field( $$node{$field} );
 160         }
 161
 162         try {
 163                 $rec->update;
 164                 $client->respond( $rec->id );
 165         } catech Error with {
 166                 $client->respond( 0 );
 167         };
 168
 169         return undef;
 170 }
 171 __PACKAGE__->register_method(
 172         method          => 'update_record_node',
 173         api_name        => 'open-ils.storage.biblio.record_node.update',
 174         api_level       => 1,
 175         argc            => 1,
 176 );
 177
 178
 179
 180 sub get_record_entry {
 181         my $self = shift;
 182         my $client = shift;
 183         my @ids = @_;
 184
 185         for my $id ( @ids ) {
 186                 next unless ($id);
 187
 188                 my $rec = biblio::record_entry->retrieve("$id");
 189                 $client->respond( $self->_cdbi2Hash( $rec ) ) if ($rec);
 190
 191                 last if ($self->api_name !~ /list/o);
 192         }
 193         return undef;
 194 }
 195 __PACKAGE__->register_method(
 196         method          => 'get_record_entry',
 197         api_name        => 'open-ils.storage.biblio.record_entry.retrieve',
 198         api_level       => 1,
 199         argc            => 1,
 200 );
 201 __PACKAGE__->register_method(
 202         method          => 'get_record_entry',
 203         api_name        => 'open-ils.storage.biblio.record_entry.retrieve.list',
 204         api_level       => 1,
 205         argc            => 1,
 206         stream          => 1,
 207 );
 208
 209 sub get_record_node {
 210         my $self = shift;
 211         my $client = shift;
 212         my @ids = @_;
 213
 214         for my $id ( @ids ) {
 215                 next unless ($id);
 216
 217                 my $rec = biblio::record_node->retrieve("$id");
 218                 $client->respond( $self->_cdbi2Hash( $rec ) ) if ($rec);
 219
 220                 last if ($self->api_name !~ /list/o);
 221         }
 222         return undef;
 223 }
 224 __PACKAGE__->register_method(
 225         method          => 'get_record_node',
 226         api_name        => 'open-ils.storage.biblio.record_node.retrieve',
 227         api_level       => 1,
 228         argc            => 1,
 229 );
 230 __PACKAGE__->register_method(
 231         method          => 'get_record_node',
 232         api_name        => 'open-ils.storage.biblio.record_node.retrieve.list',
 233         api_level       => 1,
 234         argc            => 1,
 235         stream          => 1,
 236 );
 237
 238 sub get_record_nodeset {
 239         my $self = shift;
 240         my $client = shift;
 241         my @ids = @_;
 242
 243         my $table = biblio::record_node->table;
 244         my @fields = Fieldmapper::biblio::record_node->real_fields;
 245         my $field_list = join ',', @fields;
 246
 247         my $sth = biblio::record_node->db_Main->prepare_cached(<<"      SQL");
 248                 SELECT  $field_list
 249                   FROM  $table
 250                   WHERE owner_doc = ?
 251                   ORDER BY intra_doc_id;
 252         SQL
 253
 254
 255         for my $id ( @ids ) {
 256                 next unless ($id);
 257
 258                 $sth->execute($id);
 259
 260
 261                 my @nodeset;
 262                 while (my $data = $sth->fetchrow_arrayref) {
 263                         my $n = new Fieldmapper::biblio::record_node;
 264                         my $index = 0;
 265                         for my $f ( @fields ) {
 266                                 $n->$f( $$data[$index] );
 267                                 $index++;
 268                         }
 269                         push @nodeset, $n;
 270                 }
 271                 $sth->finish;
 272
 273                 $client->respond( \@nodeset );
 274
 275                 last if ($self->api_name !~ /list/o);
 276         }
 277         return undef;
 278 }
 279 __PACKAGE__->register_method(
 280         method          => 'get_record_nodeset',
 281         api_name        => 'open-ils.storage.biblio.record_entry.nodeset.retrieve',
 282         api_level       => 1,
 283         argc            => 1,
 284 );
 285 __PACKAGE__->register_method(
 286         method          => 'get_record_nodeset',
 287         api_name        => 'open-ils.storage.biblio.record_entry.nodeset.retrieve.list',
 288         api_level       => 1,
 289         argc            => 1,
 290         stream          => 1,
 291 );
 292
 293
 294 1;