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_entry {
   8         my $self = shift;
   9         my $client = shift;
  10         my $metadata = shift;
  11
  12         my %hash = map { ( $_ => $metadata->$_) } Fieldmapper::biblio::record_entry->real_fields;
  13
  14         try {
  15                 my $rec = biblio::record_entry->create(\%hash);
  16                 $client->respond( $rec->id );
  17         } catch Error with {
  18                 $client->respond( 0 );
  19         };
  20
  21         return undef;
  22 }
  23 __PACKAGE__->register_method(
  24         method          => 'create_record_entry',
  25         api_name        => 'open-ils.storage.biblio.record_entry.create',
  26         api_level       => 1,
  27         argc            => 2,
  28         note            => <<TEXT,
  29
  30 Params should be passed as a hash ref!
  31 Required fields are:
  32
  33         creator
  34         editor
  35
  36 Please at least try to fill in:
  37
  38         tcn_source
  39         tcn_value
  40         metarecord
  41         source
  42         active
  43
  44 TEXT
  45
  46 );
  47
  48 sub update_record_entry {
  49         my $self = shift;
  50         my $client = shift;
  51         my $entry = shift;
  52
  53         my $rec = biblio::record_entry->retrieve(''.$entry->id);
  54         return 0 unless ($rec);
  55
  56         $rec->autoupdate(0);
  57
  58         for my $field ( Fieldmapper::biblio::record_entry->real_fields ) {
  59                 $rec->$field( $entry->$field );
  60         }
  61
  62         return 0 unless ($rec->is_changed);
  63
  64         $rec->update;
  65
  66         return 1;
  67 }
  68 __PACKAGE__->register_method(
  69         method          => 'update_record_entry',
  70         api_name        => 'open-ils.storage.biblio.record_entry.update',
  71         api_level       => 1,
  72         argc            => 1,
  73 );
  74
  75 sub delete_record_entry {
  76         my $self = shift;
  77         my $client = shift;
  78         my $entry = shift;
  79
  80         my $rec = biblio::record_entry->retrieve(''.$entry->id);
  81         return 0 unless ($rec);
  82
  83         $rec->delete;
  84         return 1;
  85 }
  86 __PACKAGE__->register_method(
  87         method          => 'delete_record_entry',
  88         api_name        => 'open-ils.storage.biblio.record_entry.delete',
  89         api_level       => 1,
  90         argc            => 1,
  91 );
  92
  93 sub search_record_entry_one_field {
  94         my $self = shift;
  95         my $client = shift;
  96         my @ids = @_;
  97
  98         (my $search_field = $self->api_name) =~ s/^.*retrieve\.([^\.]+).*?$/$1/o;
  99
 100         my @fields = Fieldmapper::biblio::record_entry->real_fields;
 101         for my $id ( @ids ) {
 102                 next unless ($id);
 103
 104                 my $fm = new Fieldmapper::biblio::record_entry;
 105                 for my $rec ( biblio::record_entry->search($search_field => "$id") ) {
 106                         for my $f (@fields) {
 107                                 $fm->$f( $rec->$f );
 108                         }
 109                         $client->respond( $fm ) if ($rec);
 110                 }
 111
 112                 last if ($self->api_name !~ /list/o);
 113         }
 114         return undef;
 115 }
 116 __PACKAGE__->register_method(
 117         method          => 'search_record_entry_one_field',
 118         api_name        => 'open-ils.storage.biblio.record_entry.search.tcn_value',
 119         api_level       => 1,
 120         argc            => 1,
 121         stream          => 1,
 122 );
 123 __PACKAGE__->register_method(
 124         method          => 'search_record_entry_one_field',
 125         api_name        => 'open-ils.storage.biblio.record_entry.search.tcn_value.list',
 126         api_level       => 1,
 127         argc            => 1,
 128         stream          => 1,
 129 );
 130
 131 sub get_record_entry {
 132         my $self = shift;
 133         my $client = shift;
 134         my @ids = @_;
 135
 136         my @fields = Fieldmapper::biblio::record_entry->real_fields;
 137         for my $id ( @ids ) {
 138                 next unless ($id);
 139
 140                 my $fm = new Fieldmapper::biblio::record_entry;
 141                 my $rec = biblio::record_entry->retrieve("$id");
 142                 for my $f (@fields) {
 143                         $fm->$f( $rec->$f );
 144                 }
 145                 $client->respond( $fm ) if ($rec);
 146
 147                 last if ($self->api_name !~ /list/o);
 148         }
 149         return undef;
 150 }
 151 __PACKAGE__->register_method(
 152         method          => 'get_record_entry',
 153         api_name        => 'open-ils.storage.biblio.record_entry.retrieve',
 154         api_level       => 1,
 155         argc            => 1,
 156 );
 157 __PACKAGE__->register_method(
 158         method          => 'get_record_entry',
 159         api_name        => 'open-ils.storage.biblio.record_entry.retrieve.list',
 160         api_level       => 1,
 161         argc            => 1,
 162         stream          => 1,
 163 );
 164
 165 sub create_record_node {
 166         my $self = shift;
 167         my $client = shift;
 168         my $node = shift;;
 169
 170         my %hash = map { ( $_ => $node->$_) } Fieldmapper::biblio::record_node->real_fields;
 171
 172         try {
 173                 my $n = biblio::record_node->create(\%hash);
 174                 $client->respond( $n->id );
 175         } catch Error with {
 176                 $client->respond( 0 );
 177         };
 178
 179         return undef;
 180 }
 181 __PACKAGE__->register_method(
 182         method          => 'create_record_node',
 183         api_name        => 'open-ils.storage.biblio.record_node.create',
 184         api_level       => 1,
 185         argc            => 1,
 186 );
 187
 188 sub update_record_node {
 189         my $self = shift;
 190         my $client = shift;
 191         my $node = shift;;
 192
 193
 194         my $n = biblio::record_node->retrieve(''.$node->id);
 195         return 0 unless ($n);
 196
 197         $n->autoupdate(0);
 198
 199         for my $field ( Fieldmapper::biblio::record_node->real_fields ) {
 200                 $n->$field( $node->$field );
 201         }
 202
 203         $n->update;
 204         return 1;
 205 }
 206 __PACKAGE__->register_method(
 207         method          => 'update_record_node',
 208         api_name        => 'open-ils.storage.biblio.record_node.update',
 209         api_level       => 1,
 210         argc            => 1,
 211 );
 212
 213 sub delete_record_node {
 214         my $self = shift;
 215         my $client = shift;
 216         my $node = shift;
 217
 218         my $rec = biblio::record_node->retrieve(''.$node->id);
 219         return 0 unless ($rec);
 220
 221         $rec->delete;
 222
 223         return 1;
 224 }
 225 __PACKAGE__->register_method(
 226         method          => 'delete_record_node',
 227         api_name        => 'open-ils.storage.biblio.record_node.delete',
 228         api_level       => 1,
 229         argc            => 1,
 230 );
 231
 232 sub get_record_node {
 233         my $self = shift;
 234         my $client = shift;
 235         my @ids = @_;
 236
 237         for my $id ( @ids ) {
 238                 next unless ($id);
 239
 240                 my $rec = biblio::record_node->retrieve("$id");
 241                 $client->respond( $self->_cdbi2Hash( $rec ) ) if ($rec);
 242
 243                 last if ($self->api_name !~ /list/o);
 244         }
 245         return undef;
 246 }
 247 __PACKAGE__->register_method(
 248         method          => 'get_record_node',
 249         api_name        => 'open-ils.storage.biblio.record_node.retrieve',
 250         api_level       => 1,
 251         argc            => 1,
 252 );
 253 __PACKAGE__->register_method(
 254         method          => 'get_record_node',
 255         api_name        => 'open-ils.storage.biblio.record_node.retrieve.list',
 256         api_level       => 1,
 257         argc            => 1,
 258         stream          => 1,
 259 );
 260
 261 sub create_record_nodeset {
 262         my $self = shift;
 263         my $client = shift;
 264
 265         my $method = $self->method_lookup('open-ils.storage.biblio.record_node.create');
 266
 267         my @success;
 268         while ( my $node = shift(@_) ) {
 269                 my ($res) = $method->run( $node );
 270                 push @success, $res if ($res);
 271         }
 272
 273         my $insert_total = 0;
 274         $insert_total += $_ for (@success);
 275
 276         return $insert_total;
 277 }
 278 __PACKAGE__->register_method(
 279         method          => 'create_record_nodeset',
 280         api_name        => 'open-ils.storage.biblio.record_node.batch.create',
 281         api_level       => 1,
 282         argc            => 1,
 283 );
 284
 285 sub update_record_nodeset {
 286         my $self = shift;
 287         my $client = shift;
 288
 289         my $method = $self->method_lookup('open-ils.storage.biblio.record_node.update');
 290
 291         my @success;
 292         while ( my $node = shift(@_) ) {
 293                 my ($res) = $method->run( $node );
 294                 push @success, $res if ($res);
 295         }
 296
 297         my $update_total = 0;
 298         $update_total += $_ for (@success);
 299
 300         return $update_total;
 301 }
 302 __PACKAGE__->register_method(
 303         method          => 'create_record_nodeset',
 304         api_name        => 'open-ils.storage.biblio.record_node.batch.update',
 305         api_level       => 1,
 306         argc            => 1,
 307 );
 308
 309 sub delete_record_nodeset {
 310         my $self = shift;
 311         my $client = shift;
 312
 313         my $method = $self->method_lookup('open-ils.storage.biblio.record_node.delete');
 314
 315         my @success;
 316         while ( my $node = shift(@_) ) {
 317                 my ($res) = $method->run( $node );
 318                 push @success, $res if ($res);
 319         }
 320
 321         my $delete_total = 0;
 322         $delete_total += $_ for (@success);
 323
 324         return $delete_total;
 325 }
 326 __PACKAGE__->register_method(
 327         method          => 'create_record_nodeset',
 328         api_name        => 'open-ils.storage.biblio.record_node.batch.delete',
 329         api_level       => 1,
 330         argc            => 1,
 331 );
 332
 333 sub get_record_nodeset {
 334         my $self = shift;
 335         my $client = shift;
 336         my @ids = @_;
 337
 338         my $table = biblio::record_node->table;
 339         my @fields = Fieldmapper::biblio::record_node->real_fields;
 340         my $field_list = join ',', @fields;
 341
 342         my $sth = biblio::record_node->db_Main->prepare_cached(<<"      SQL");
 343                 SELECT  $field_list
 344                   FROM  $table
 345                   WHERE owner_doc = ?
 346                   ORDER BY intra_doc_id;
 347         SQL
 348
 349
 350         for my $id ( @ids ) {
 351                 next unless ($id);
 352
 353                 $sth->execute("$id");
 354
 355
 356                 my @nodeset;
 357                 while (my $data = $sth->fetchrow_arrayref) {
 358                         my $n = new Fieldmapper::biblio::record_node;
 359                         my $index = 0;
 360                         for my $f ( @fields ) {
 361                                 $n->$f( $$data[$index] );
 362                                 $index++;
 363                         }
 364                         push @nodeset, $n;
 365                 }
 366                 $sth->finish;
 367
 368                 $client->respond( \@nodeset );
 369
 370                 last if ($self->api_name !~ /list/o);
 371         }
 372         return undef;
 373 }
 374 __PACKAGE__->register_method(
 375         method          => 'get_record_nodeset',
 376         api_name        => 'open-ils.storage.biblio.record_entry.nodeset.retrieve',
 377         api_level       => 1,
 378         argc            => 1,
 379 );
 380 __PACKAGE__->register_method(
 381         method          => 'get_record_nodeset',
 382         api_name        => 'open-ils.storage.biblio.record_entry.nodeset.retrieve.list',
 383         api_level       => 1,
 384         argc            => 1,
 385         stream          => 1,
 386 );
 387
 388
 389 1;