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

   1 package OpenILS::Application::Storage::Publisher::biblio;
   2 use base qw/OpenILS::Application::Storage/;
   3 use vars qw/$VERSION/;
   4 use OpenSRF::EX qw/:try/;
   5 #use OpenILS::Application::Storage::CDBI::biblio;
   6 #use OpenILS::Application::Storage::CDBI::asset;
   7 use OpenILS::Utils::Fieldmapper;
   8
   9 $VERSION = 1;
  10
  11 sub record_copy_count {
  12     my $self = shift;
  13     my $client = shift;
  14
  15     my %args = @_;
  16
  17     my $cn_table = asset::call_number->table;
  18     my $cp_table = asset::copy->table;
  19     my $st_table = config::copy_status->table;
  20     my $src_table = config::bib_source->table;
  21     my $br_table = biblio::record_entry->table;
  22     my $loc_table = asset::copy_location->table;
  23     my $out_table = actor::org_unit_type->table;
  24
  25     my $descendants = "actor.org_unit_descendants(u.id)";
  26     my $ancestors = "actor.org_unit_ancestors(?) u JOIN $out_table t ON (u.ou_type = t.id)";
  27
  28     if ($args{org_unit} < 0) {
  29         $args{org_unit} *= -1;
  30         $ancestors = "(select org_unit as id from actor.org_lasso_map where lasso = ?) u CROSS JOIN (SELECT -1 AS depth) t";
  31     }
  32
  33     my $visible = 'AND a.opac_visible = TRUE AND st.opac_visible = TRUE AND loc.opac_visible = TRUE AND cp.opac_visible = TRUE';
  34     if ($self->api_name =~ /staff/o) {
  35         $visible = ''
  36     }
  37
  38     my $sql = <<"    SQL";
  39         SELECT  t.depth,
  40             u.id AS org_unit,
  41             sum(
  42                 (SELECT count(cp.id)
  43                   FROM  $cn_table cn
  44                     JOIN $cp_table cp ON (cn.id = cp.call_number)
  45                     JOIN $descendants a ON (cp.circ_lib = a.id)
  46                     JOIN $st_table st ON (cp.status = st.id)
  47                     JOIN $loc_table loc ON (cp.location = loc.id)
  48                   WHERE cn.record = ?
  49                     $visible
  50                     AND cn.deleted IS FALSE
  51                     AND cp.deleted IS FALSE)
  52             ) AS count,
  53             sum(
  54                 (SELECT count(cp.id)
  55                   FROM  $cn_table cn
  56                     JOIN $cp_table cp ON (cn.id = cp.call_number)
  57                     JOIN $descendants a ON (cp.circ_lib = a.id)
  58                     JOIN $st_table st ON (cp.status = st.id)
  59                     JOIN $loc_table loc ON (cp.location = loc.id)
  60                   WHERE cn.record = ?
  61                     $visible
  62                     AND cn.deleted IS FALSE
  63                     AND cp.deleted IS FALSE
  64                     AND cp.status IN (0,7,12))
  65             ) AS available,
  66             sum(
  67                 (SELECT count(cp.id)
  68                   FROM  $cn_table cn
  69                     JOIN $cp_table cp ON (cn.id = cp.call_number)
  70                     JOIN $st_table st ON (cp.status = st.id)
  71                     JOIN $loc_table loc ON (cp.location = loc.id)
  72                   WHERE cn.record = ?
  73                     AND st.opac_visible = TRUE
  74                     AND loc.opac_visible = TRUE
  75                     AND cp.opac_visible = TRUE
  76                     AND cn.deleted IS FALSE
  77                     AND cp.deleted IS FALSE)
  78             ) AS unshadow,
  79                         sum(
  80                                 (SELECT sum(1)
  81                                   FROM  $br_table br
  82                                         JOIN $src_table src ON (src.id = br.source)
  83                                   WHERE br.id = ?
  84                                         AND src.transcendant IS TRUE
  85                                 )
  86                         ) AS transcendant
  87           FROM  $ancestors
  88           GROUP BY 1,2
  89     SQL
  90
  91     my $sth = biblio::record_entry->db_Main->prepare_cached($sql);
  92     $sth->execute(''.$args{record}, ''.$args{record}, ''.$args{record}, ''.$args{record}, ''.$args{org_unit});
  93     while ( my $row = $sth->fetchrow_hashref ) {
  94         $client->respond( $row );
  95     }
  96     return undef;
  97 }
  98 __PACKAGE__->register_method(
  99     api_name    => 'open-ils.storage.biblio.record_entry.copy_count',
 100     method      => 'record_copy_count',
 101     api_level   => 1,
 102     stream      => 1,
 103     cachable    => 1,
 104 );
 105 __PACKAGE__->register_method(
 106     api_name    => 'open-ils.storage.biblio.record_entry.copy_count.staff',
 107     method      => 'record_copy_count',
 108     api_level   => 1,
 109     stream      => 1,
 110     cachable    => 1,
 111 );
 112
 113 sub record_ranged_tree {
 114     my $self = shift;
 115     my $client = shift;
 116     my $r = shift;
 117     my $ou = shift;
 118     my $depth = shift;
 119     my $limit = shift || 0;
 120     my $offset = shift || 0;
 121
 122     my $ou_sql = defined($depth) ?
 123             "SELECT id FROM actor.org_unit_descendants(?,?)":
 124             "SELECT id FROM actor.org_unit_descendants(?)";
 125
 126     my $ou_list =
 127         actor::org_unit
 128             ->db_Main
 129             ->selectcol_arrayref(
 130                 $ou_sql,
 131                 {},
 132                 $ou,
 133                 (defined($depth) ? ($depth) : ()),
 134             );
 135
 136     return undef unless ($ou_list and @$ou_list);
 137
 138     $r = biblio::record_entry->retrieve( $r );
 139     return undef unless ($r);
 140
 141     my $rec = $r->to_fieldmapper;
 142     $rec->call_numbers([]);
 143
 144     $rec->fixed_fields( $r->record_descriptor->next->to_fieldmapper );
 145
 146     my $offset_count = 0;
 147     my $limit_count = 0;
 148     for my $cn ( $r->call_numbers  ) {
 149         next if ($cn->deleted);
 150         my $call_number = $cn->to_fieldmapper;
 151         $call_number->copies([]);
 152
 153
 154         for my $cp ( $cn->copies(circ_lib => $ou_list) ) {
 155             next if ($cp->deleted);
 156             if ($offset > 0 && $offset_count < $offset) {
 157                 $offset_count++;
 158                 next;
 159             }
 160
 161             last if ($limit > 0 && $limit_count >= $limit);
 162
 163             my $copy = $cp->to_fieldmapper;
 164             $copy->status( $cp->status->to_fieldmapper );
 165             $copy->location( $cp->location->to_fieldmapper );
 166             push @{ $call_number->copies }, $copy;
 167
 168             $limit_count++;
 169         }
 170
 171         last if ($limit > 0 && $limit_count >= $limit);
 172
 173         push @{ $rec->call_numbers }, $call_number if (@{ $call_number->copies });
 174     }
 175
 176     return $rec;
 177 }
 178 __PACKAGE__->register_method(
 179     api_name    => 'open-ils.storage.biblio.record_entry.ranged_tree',
 180     method      => 'record_ranged_tree',
 181     argc        => 1,
 182     api_level   => 1,
 183 );
 184
 185 sub record_by_barcode {
 186     my $self = shift;
 187     my $client = shift;
 188
 189     my $cn_table = asset::call_number->table;
 190     my $cp_table = asset::copy->table;
 191
 192     my $id = ''.shift;
 193     my ($r) = biblio::record_entry->db_Main->selectrow_array( <<"    SQL", {}, $id );
 194         SELECT  cn.record
 195           FROM  $cn_table cn
 196             JOIN $cp_table cp ON (cp.call_number = cn.id)
 197           WHERE cp.barcode = ?
 198     SQL
 199
 200     my $rec = biblio::record_entry->retrieve( $r );
 201
 202     return $rec->to_fieldmapper if ($rec);
 203     return undef;
 204 }
 205 __PACKAGE__->register_method(
 206     api_name    => 'open-ils.storage.biblio.record_entry.retrieve_by_barcode',
 207     method      => 'record_by_barcode',
 208     api_level   => 1,
 209     cachable    => 1,
 210 );
 211
 212 sub record_by_copy {
 213     my $self = shift;
 214     my $client = shift;
 215
 216     my $cn_table = asset::call_number->table;
 217     my $cp_table = asset::copy->table;
 218
 219     my $id = ''.shift;
 220     my ($r) = biblio::record_entry->db_Main->selectrow_array( <<"    SQL", {}, $id );
 221         SELECT  cn.record
 222           FROM  $cn_table cn
 223             JOIN $cp_table cp ON (cp.call_number = cn.id)
 224           WHERE cp.id = ?
 225     SQL
 226
 227     my $rec = biblio::record_entry->retrieve( $r );
 228     return undef unless ($rec);
 229
 230     my $r_fm = $rec->to_fieldmapper;
 231     my $ff = $rec->record_descriptor->next;
 232     $r_fm->fixed_fields( $ff->to_fieldmapper ) if ($ff);
 233
 234     return $r_fm;
 235 }
 236 __PACKAGE__->register_method(
 237     api_name    => 'open-ils.storage.fleshed.biblio.record_entry.retrieve_by_copy',
 238     method      => 'record_by_copy',
 239     api_level   => 1,
 240     cachable    => 1,
 241 );
 242
 243
 244 =head1 comment Old version
 245
 246 my $org_unit_lookup;
 247 sub record_copy_count {
 248     my $self = shift;
 249     my $client = shift;
 250     my $oid = shift;
 251     my @recs = @_;
 252
 253     if ($self->api_name !~ /batch/o) {
 254         @recs = ($recs[0]);
 255     }
 256
 257     throw OpenSRF::EX::InvalidArg ( "No org_unit id passed!" )
 258         unless ($oid);
 259
 260     throw OpenSRF::EX::InvalidArg ( "No record id passed!" )
 261         unless (@recs);
 262
 263     $org_unit_lookup ||= $self->method_lookup('open-ils.storage.direct.actor.org_unit.retrieve');
 264     my ($org_unit) = $org_unit_lookup->run($oid);
 265
 266     # XXX Use descendancy tree here!!!
 267     my $short_name_hack = $org_unit->shortname;
 268     $short_name_hack = '' if (!$org_unit->parent_ou);
 269     $short_name_hack .= '%';
 270     # XXX Use descendancy tree here!!!
 271
 272     my $rec_list = join(',',@recs);
 273
 274     my $cp_table = asset::copy->table;
 275     my $cn_table = asset::call_number->table;
 276
 277     my $select =<<"    SQL";
 278         SELECT  count(cp.*) as copies
 279           FROM  $cn_table cn
 280             JOIN $cp_table cp ON (cp.call_number = cn.id)
 281           WHERE cn.owning_lib LIKE ? AND
 282             cn.record IN ($rec_list)
 283     SQL
 284
 285     my $sth = asset::copy->db_Main->prepare_cached($select);
 286     $sth->execute($short_name_hack);
 287
 288     my $results = $sth->fetchall_hashref('record');
 289
 290     $client->respond($$results{$_}{copies} || 0) for (@recs);
 291
 292     return undef;
 293 }
 294 __PACKAGE__->register_method(
 295     method      => 'record_copy_count',
 296     api_name    => 'open-ils.storage.direct.biblio.record_copy_count',
 297     api_level   => 1,
 298     argc        => 1,
 299 );
 300 __PACKAGE__->register_method(
 301     method      => 'record_copy_count',
 302     api_name    => 'open-ils.storage.direct.biblio.record_copy_count.batch',
 303     api_level   => 1,
 304     argc        => 1,
 305     stream      => 1,
 306 );
 307
 308 =cut
 309
 310 sub global_record_copy_count {
 311     my $self = shift;
 312     my $client = shift;
 313
 314     my $rec = shift;
 315
 316     my $cn_table = asset::call_number->table;
 317     my $cp_table = asset::copy->table;
 318     my $cl_table = asset::copy_location->table;
 319     my $cs_table = config::copy_status->table;
 320
 321     my $copies_visible = 'AND cp.opac_visible IS TRUE AND cs.opac_visible IS TRUE AND cl.opac_visible IS TRUE';
 322     $copies_visible = '' if ($self->api_name =~ /staff/o);
 323
 324     my $sql = <<"    SQL";
 325
 326         SELECT  owning_lib, sum(avail), sum(tot)
 327           FROM  (
 328                     SELECT  cn.owning_lib, count(cp.id) as avail, 0 as tot
 329                   FROM  $cn_table cn
 330                     JOIN $cp_table cp ON (cn.id = cp.call_number)
 331                     JOIN $cs_table cs ON (cs.id = cp.status)
 332                     JOIN $cl_table cl ON (cl.id = cp.location)
 333                   WHERE cn.record = ?
 334                     AND cp.status IN (0,7,12)
 335                     $copies_visible
 336                   GROUP BY 1
 337                                     UNION
 338                     SELECT  cn.owning_lib, 0 as avail, count(cp.id) as tot
 339                   FROM  $cn_table cn
 340                     JOIN $cp_table cp ON (cn.id = cp.call_number)
 341                     JOIN $cs_table cs ON (cs.id = cp.status)
 342                     JOIN $cl_table cl ON (cl.id = cp.location)
 343                   WHERE cn.record = ?
 344                     $copies_visible
 345                   GROUP BY 1
 346             ) x
 347           GROUP BY 1
 348     SQL
 349
 350     my $sth = biblio::record_entry->db_Main->prepare_cached($sql);
 351     $sth->execute("$rec", "$rec");
 352
 353     $client->respond( $_ ) for (@{$sth->fetchall_arrayref});
 354     return undef;
 355 }
 356 __PACKAGE__->register_method(
 357     api_name    => 'open-ils.storage.biblio.record_entry.global_copy_count',
 358     method      => 'global_record_copy_count',
 359     api_level   => 1,
 360     stream      => 1,
 361     cachable    => 1,
 362 );
 363 __PACKAGE__->register_method(
 364     api_name    => 'open-ils.storage.biblio.record_entry.global_copy_count.staff',
 365     method      => 'global_record_copy_count',
 366     api_level   => 1,
 367     stream      => 1,
 368     cachable    => 1,
 369 );
 370
 371 sub record_copy_status_count {
 372     my $self = shift;
 373     my $client = shift;
 374
 375     my $rec = shift;
 376     my $ou = shift || 1;
 377     my $depth = shift || 0;
 378
 379
 380     my $descendants = "actor.org_unit_descendants(?,?)";
 381
 382     my $cn_table = asset::call_number->table;
 383     my $cnp_table = asset::call_number_prefix->table;
 384     my $cns_table = asset::call_number_suffix->table;
 385     my $cp_table = asset::copy->table;
 386     my $cl_table = asset::copy_location->table;
 387     my $cs_table = config::copy_status->table;
 388
 389     my $sql = <<"    SQL";
 390
 391         SELECT  cp.circ_lib,
 392                 CASE WHEN cnp.id > -1 THEN cnp.label ELSE '' END,
 393                 cn.label,
 394                 CASE WHEN cns.id > -1 THEN cns.label ELSE '' END,
 395                 cp.status,
 396                 count(cp.id)
 397           FROM  $cp_table cp,
 398             $cn_table cn,
 399             $cns_table cns,
 400             $cnp_table cnp,
 401             $cl_table cl,
 402             $cs_table cs,
 403             $descendants d
 404           WHERE cn.record = ?
 405             AND cnp.id = cn.prefix
 406             AND cns.id = cn.suffix
 407             AND cp.call_number = cn.id
 408             AND cp.location = cl.id
 409             AND cp.circ_lib = d.id
 410             AND cp.status = cs.id
 411             AND cl.opac_visible IS TRUE
 412             AND cp.opac_visible IS TRUE
 413             AND cp.deleted IS FALSE
 414             AND cs.opac_visible IS TRUE
 415           GROUP BY 1,2,3,4,5;
 416     SQL
 417
 418     my $sth = biblio::record_entry->db_Main->prepare_cached($sql);
 419     $sth->execute($ou, $depth, "$rec" );
 420
 421     my %data = ();
 422     for my $row (@{$sth->fetchall_arrayref}) {
 423         $data{$$row[0]}{$$row[1]}{$$row[2]}{$$row[3]}{$$row[4]} += $$row[5];
 424     }
 425
 426     for my $ou (keys %data) {
 427         for my $cn_prefix (keys %{$data{$ou}}) {
 428             for my $cn (keys %{$data{$ou}{$cn_prefix}}) {
 429                 for my $cn_suffix (keys %{$data{$ou}{$cn_prefix}{$cn}}) {
 430                     $client->respond( [$ou, $cn_prefix, $cn, $cn_suffix, $data{$ou}{$cn}{$cn_prefix}{$cn}{$cn_suffix}] );
 431                 }
 432             }
 433         }
 434     }
 435     return undef;
 436 }
 437 __PACKAGE__->register_method(
 438     api_name    => 'open-ils.storage.biblio.record_entry.status_copy_count',
 439     method      => 'record_copy_status_count',
 440     api_level   => 1,
 441     stream      => 1,
 442     cachable    => 1,
 443 );
 444
 445
 446 sub record_copy_status_location_count {
 447     my $self = shift;
 448     my $client = shift;
 449
 450     my $rec = shift;
 451     my $ou = shift || 1;
 452     my $depth = shift || 0;
 453
 454
 455     my $descendants = "actor.org_unit_descendants(?,?)";
 456
 457     my $cn_table = asset::call_number->table;
 458     my $cnp_table = asset::call_number_prefix->table;
 459     my $cns_table = asset::call_number_suffix->table;
 460     my $cp_table = asset::copy->table;
 461     my $cl_table = asset::copy_location->table;
 462     my $cs_table = config::copy_status->table;
 463
 464     # FIXME using oils_i18n_xlate here is exposing a hitherto unexposed
 465     # implementation detail of json_query; doing it this way because
 466     # json_query currently doesn't grok joining a function to tables
 467     my $sql = <<"    SQL";
 468
 469         SELECT  cp.circ_lib,
 470                 CASE WHEN cnp.id > -1 THEN cnp.label ELSE '' END,
 471                 cn.label,
 472                 CASE WHEN cns.id > -1 THEN cns.label ELSE '' END,
 473                 oils_i18n_xlate('asset.copy_location', 'acpl', 'name', 'id', cl.id::TEXT, ?),
 474                 cp.status,
 475                 count(cp.id)
 476           FROM  $cp_table cp,
 477             $cn_table cn,
 478             $cns_table cns,
 479             $cnp_table cnp,
 480             $cl_table cl,
 481             $cs_table cs,
 482             $descendants d
 483           WHERE cn.record = ?
 484             AND cnp.id = cn.prefix
 485             AND cns.id = cn.suffix
 486             AND cp.call_number = cn.id
 487             AND cp.location = cl.id
 488             AND cp.circ_lib = d.id
 489             AND cp.status = cs.id
 490             AND cl.opac_visible IS TRUE
 491             AND cp.opac_visible IS TRUE
 492             AND cp.deleted IS FALSE
 493             AND cs.opac_visible IS TRUE
 494           GROUP BY 1,2,3,4,5,6;
 495     SQL
 496
 497     my $sth = biblio::record_entry->db_Main->prepare_cached($sql);
 498     my $ses_locale = $client->session ? $client->session->session_locale : 'en-US';
 499     $sth->execute($ses_locale, $ou, $depth, "$rec" );
 500
 501     my %data = ();
 502     for my $row (@{$sth->fetchall_arrayref}) {
 503         $data{$$row[0]}{$$row[1]}{$$row[2]}{$$row[3]}{$$row[4]}{$$row[5]} += $$row[6];
 504     }
 505
 506     for my $ou (keys %data) {
 507         for my $cn_prefix (keys %{$data{$ou}}) {
 508             for my $cn (keys %{$data{$ou}{$cn_prefix}}) {
 509                 for my $cn_suffix (keys %{$data{$ou}{$cn_prefix}{$cn}}) {
 510                     for my $cl (keys %{$data{$ou}{$cn_prefix}{$cn}{$cn_suffix}}) {
 511                         $client->respond( [$ou, $cn_prefix, $cn, $cn_suffix, $cl, $data{$ou}{$cn_prefix}{$cn}{$cn_suffix}{$cl}] );
 512                     }
 513                 }
 514             }
 515         }
 516     }
 517     return undef;
 518 }
 519 __PACKAGE__->register_method(
 520     api_name    => 'open-ils.storage.biblio.record_entry.status_copy_location_count',
 521     method      => 'record_copy_status_location_count',
 522     api_level   => 1,
 523     stream      => 1,
 524     cachable    => 1,
 525 );
 526
 527 1;