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

   1 package OpenILS::Application::Storage::Publisher::actor;
   2 use base qw/OpenILS::Application::Storage/;
   3 use OpenILS::Application::Storage::CDBI::actor;
   4 use OpenSRF::Utils::Logger qw/:level/;
   5 use OpenSRF::Utils qw/:datetime/;
   6 use OpenILS::Utils::Fieldmapper;
   7
   8 use DateTime;
   9 use DateTime::Format::ISO8601;
  10
  11
  12 my $_dt_parser = DateTime::Format::ISO8601->new;
  13
  14 my $log = 'OpenSRF::Utils::Logger';
  15
  16 sub new_usergroup_id {
  17         return actor::user->db_Main->selectrow_array("select nextval('actor.usr_usrgroup_seq'::regclass)");
  18 }
  19 __PACKAGE__->register_method(
  20         api_name        => 'open-ils.storage.actor.user.group_id.new',
  21         api_level       => 1,
  22         method          => 'new_usergroup_id',
  23 );
  24
  25 sub calc_proximity {
  26         my $self = shift;
  27         my $client = shift;
  28
  29         local $OpenILS::Application::Storage::WRITE = 1;
  30
  31         my $delete_sql = <<"    SQL";
  32                 DELETE FROM actor.org_unit_proximity;
  33         SQL
  34
  35         my $insert_sql = <<"    SQL";
  36                 INSERT INTO actor.org_unit_proximity (from_org, to_org, prox)
  37                         SELECT  l.id,
  38                                 r.id,
  39                                 actor.org_unit_proximity(l.id,r.id)
  40                           FROM  actor.org_unit l,
  41                                 actor.org_unit r;
  42         SQL
  43
  44         actor::org_unit_proximity->db_Main->do($delete_sql);
  45         actor::org_unit_proximity->db_Main->do($insert_sql);
  46
  47         return 1;
  48 }
  49 __PACKAGE__->register_method(
  50         api_name        => 'open-ils.storage.actor.org_unit.refresh_proximity',
  51         api_level       => 1,
  52         method          => 'calc_proximity',
  53 );
  54
  55
  56 sub org_closed_overlap {
  57         my $self = shift;
  58         my $client = shift;
  59         my $ou = shift;
  60         my $date = shift;
  61         my $direction = shift || 0;
  62
  63         return undef unless ($date && $ou);
  64
  65         my $t = actor::org_unit::closed_date->table;
  66         my $sql = <<"   SQL";
  67                 SELECT  *
  68                   FROM  $t
  69                   WHERE ? between close_start and close_end
  70                         AND org_unit = ?
  71                   ORDER BY close_start ASC, close_end DESC
  72         SQL
  73
  74         my $sth = actor::org_unit::closed_date->db_Main->prepare( $sql );
  75         $sth->execute($date, $ou);
  76
  77         my ($begin, $end);
  78         while (my $closure = $sth->fetchrow_hashref) {
  79                 $begin ||= $closure->{close_start};
  80                 $end = $closure->{close_end};
  81
  82                 my $before = $_dt_parser->parse_datetime( clense_ISO8601($begin) );
  83                 $before->subtract( seconds => 1 );
  84                 my $after = $_dt_parser->parse_datetime( clense_ISO8601($end) );
  85                 $after->add( seconds => 1 );
  86
  87                 if ( $direction <= 0 ) {
  88                         while ( my $_b = org_closed_overlap($self, $client, $ou, $before->iso8601, -1 ) ) {
  89                                 $before = $_dt_parser->parse_datetime( clense_ISO8601($_b->{start}) );
  90                         }
  91                 }
  92
  93                 if ( $direction >= 0 ) {
  94                         while ( my $_a = org_closed_overlap($self, $client, $ou, $after->iso8601, 1 ) ) {
  95                                 $after = $_dt_parser->parse_datetime( clense_ISO8601($_a->{end}) );
  96                         }
  97                 }
  98
  99                 $begin = clense_ISO8601($before->iso8601);
 100                 $end = clense_ISO8601($after->iso8601);
 101         }
 102
 103         if ($begin && $end) {
 104                 return { start => $begin, end => $end };
 105         }
 106
 107         return;
 108 }
 109 __PACKAGE__->register_method(
 110         api_name        => 'open-ils.storage.actor.org_unit.closed_date.overlap',
 111         api_level       => 1,
 112         method          => 'org_closed_overlap',
 113 );
 114
 115 sub user_by_barcode {
 116         my $self = shift;
 117         my $client = shift;
 118         my @barcodes = shift;
 119
 120         return undef unless @barcodes;
 121
 122         for my $card ( actor::card->search( { barcode => @barcodes } ) ) {
 123                 next unless $card;
 124                 if (@barcodes == 1) {
 125                         return $card->usr->to_fieldmapper;
 126                 }
 127                 $client->respond( $card->usr->to_fieldmapper);
 128         }
 129         return undef;
 130 }
 131 __PACKAGE__->register_method(
 132         api_name        => 'open-ils.storage.direct.actor.user.search.barcode',
 133         api_level       => 1,
 134         method          => 'user_by_barcode',
 135         stream          => 1,
 136         cachable        => 1,
 137 );
 138
 139 sub lost_barcodes {
 140         my $self = shift;
 141         my $client = shift;
 142
 143         my $c = actor::card->table;
 144         my $p = actor::user->table;
 145
 146         my $sql = "SELECT c.barcode FROM $c c JOIN $p p ON (c.usr = p.id) WHERE p.card <> c.id";
 147
 148         my $list = actor::user->db_Main->selectcol_arrayref($sql);
 149         for my $bc ( @$list ) {
 150                 $client->respond($bc);
 151         }
 152         return undef;
 153 }
 154 __PACKAGE__->register_method(
 155         api_name        => 'open-ils.storage.actor.user.lost_barcodes',
 156         api_level       => 1,
 157         stream          => 1,
 158         method          => 'lost_barcodes',
 159         signature       => <<'  NOTE',
 160                 Returns an array of barcodes that belong to lost cards.
 161                 @return array of barcodes
 162         NOTE
 163 );
 164
 165 sub expired_barcodes {
 166         my $self = shift;
 167         my $client = shift;
 168
 169         my $c = actor::card->table;
 170         my $p = actor::user->table;
 171
 172         my $sql = "SELECT c.barcode FROM $c c JOIN $p p ON (c.usr = p.id) WHERE p.expire_date < CURRENT_DATE";
 173
 174         my $list = actor::user->db_Main->selectcol_arrayref($sql);
 175         for my $bc ( @$list ) {
 176                 $client->respond($bc);
 177         }
 178         return undef;
 179 }
 180 __PACKAGE__->register_method(
 181         api_name        => 'open-ils.storage.actor.user.expired_barcodes',
 182         api_level       => 1,
 183         stream          => 1,
 184         method          => 'expired_barcodes',
 185         signature       => <<'  NOTE',
 186                 Returns an array of barcodes that are currently expired.
 187                 @return array of barcodes
 188         NOTE
 189 );
 190
 191 sub barred_barcodes {
 192         my $self = shift;
 193         my $client = shift;
 194
 195         my $c = actor::card->table;
 196         my $p = actor::user->table;
 197
 198         my $sql = "SELECT c.barcode FROM $c c JOIN $p p ON (c.usr = p.id) WHERE p.barred IS TRUE";
 199
 200         my $list = actor::user->db_Main->selectcol_arrayref($sql);
 201         for my $bc ( @$list ) {
 202                 $client->respond($bc);
 203         }
 204         return undef;
 205 }
 206 __PACKAGE__->register_method(
 207         api_name        => 'open-ils.storage.actor.user.barred_barcodes',
 208         api_level       => 1,
 209         stream          => 1,
 210         method          => 'barred_barcodes',
 211         signature       => <<'  NOTE',
 212                 Returns an array of barcodes that are currently barred.
 213                 @return array of barcodes
 214         NOTE
 215 );
 216
 217 sub penalized_barcodes {
 218         my $self = shift;
 219         my $client = shift;
 220         my @ignore = @_;
 221
 222         my $c = actor::card->table;
 223         my $p = actor::user_standing_penalty->table;
 224
 225         my $sql = "SELECT c.barcode FROM $c c JOIN $p p USING (usr)";
 226
 227         if (@ignore) {
 228                 $sql .= ' WHERE penalty_type NOT IN ('. join(',', map { '?' } @ignore) . ')';
 229         }
 230
 231         $sql .= ' GROUP BY c.barcode;';
 232
 233         my $list = actor::user->db_Main->selectcol_arrayref($sql, {}, @ignore);
 234         for my $bc ( @$list ) {
 235                 $client->respond($bc);
 236         }
 237         return undef;
 238 }
 239 __PACKAGE__->register_method(
 240         api_name        => 'open-ils.storage.actor.user.penalized_barcodes',
 241         api_level       => 1,
 242         stream          => 1,
 243         method          => 'penalized_barcodes',
 244         signature       => <<'  NOTE',
 245                 Returns an array of barcodes that have penalties not listed
 246                 as a parameter.  Supply a list of any penalty types that should
 247                 not stop a patron from checking out materials.
 248
 249                 @param ignore_list Penalty type to ignore
 250                 @return array of barcodes
 251         NOTE
 252 );
 253
 254
 255 sub patron_search {
 256         my $self = shift;
 257         my $client = shift;
 258         my $search = shift;
 259         my $limit = shift || 1000;
 260         my $sort = shift;
 261         my $inactive = shift;
 262         $sort = ['family_name','first_given_name'] unless ($$sort[0]);
 263
 264         # group 0 = user
 265         # group 1 = address
 266         # group 2 = phone, ident
 267
 268         my $usr = join ' AND ', map { "LOWER($_) ~ ?" } grep { ''.$$search{$_}{group} eq '0' } keys %$search;
 269         my @usrv = map { "^$$search{$_}{value}" } grep { ''.$$search{$_}{group} eq '0' } keys %$search;
 270
 271         my $addr = join ' AND ', map { "LOWER($_) ~ ?" } grep { ''.$$search{$_}{group} eq '1' } keys %$search;
 272         my @addrv = map { "^$$search{$_}{value}" } grep { ''.$$search{$_}{group} eq '1' } keys %$search;
 273
 274         my $pv = $$search{phone}{value};
 275         my $iv = $$search{ident}{value};
 276         my $nv = $$search{name}{value};
 277
 278         my $phone = '';
 279         my @ps;
 280         my @phonev;
 281         if ($pv) {
 282                 for my $p ( qw/day_phone evening_phone other_phone/ ) {
 283                         push @ps, "LOWER($p) ~ ?";
 284                         push @phonev, "^$pv";
 285                 }
 286                 $phone = '(' . join(' OR ', @ps) . ')';
 287         }
 288
 289         my $ident = '';
 290         my @is;
 291         my @identv;
 292         if ($iv) {
 293                 for my $i ( qw/ident_value ident_value2/ ) {
 294                         push @is, "LOWER($i) ~ ?";
 295                         push @identv, "^$iv";
 296                 }
 297                 $ident = '(' . join(' OR ', @is) . ')';
 298         }
 299
 300         my $name = '';
 301         my @ns;
 302         my @namev;
 303         if (0 && $nv) {
 304                 for my $n ( qw/first_given_name second_given_name family_name/ ) {
 305                         push @ns, "LOWER($i) ~ ?";
 306                         push @namev, "^$nv";
 307                 }
 308                 $name = '(' . join(' OR ', @ns) . ')';
 309         }
 310
 311         my $usr_where = join ' AND ', grep { $_ } ($usr,$phone,$ident,$name);
 312         my $addr_where = $addr;
 313
 314
 315         my $u_table = actor::user->table;
 316         my $a_table = actor::user_address->table;
 317
 318         my $u_select = "SELECT id as id FROM $u_table u WHERE $usr_where";
 319         my $a_select = "SELECT usr as id FROM $a_table a WHERE $addr_where";
 320         my $clone_select = "JOIN (SELECT cu.id as id FROM $a_table ca ".
 321                            "JOIN $u_table cu ON (cu.mailing_address = ca.id OR cu.billing_address = ca.id) ".
 322                            "WHERE $addr_where) AS clone USING (id)" if ($addr_where);
 323
 324         my $select = '';
 325         if ($usr_where) {
 326                 if ($addr_where) {
 327                         $select = "$u_select INTERSECT $a_select";
 328                 } else {
 329                         $select = $u_select;
 330                 }
 331         } elsif ($addr_where) {
 332                 $select = "$a_select";
 333         } else {
 334                 return undef;
 335         }
 336
 337         my $order_by = join ', ', map { 'users.'. $_} @$sort;
 338
 339         if ($inactive) {
 340                 $inactive = '';
 341         } else {
 342                 $inactive = 'AND users.active = TRUE';
 343         }
 344
 345         $select = <<"   SQL";
 346                 SELECT  users.id
 347                   FROM  $u_table AS users
 348                         JOIN ($select) AS search
 349                   USING (id)
 350                   $clone_select
 351                   WHERE users.deleted = FALSE $inactive
 352                   ORDER BY $order_by
 353                   LIMIT $limit
 354         SQL
 355
 356         return actor::user->db_Main->selectcol_arrayref($select, {}, map {lc($_)} (@usrv,@phonev,@identv,@namev,@addrv,@addrv));
 357 }
 358 __PACKAGE__->register_method(
 359         api_name        => 'open-ils.storage.actor.user.crazy_search',
 360         api_level       => 1,
 361         method          => 'patron_search',
 362 );
 363
 364 =comment not gonna use it...
 365
 366 sub fleshed_search {
 367         my $self = shift;
 368         my $client = shift;
 369         my $searches = shift;
 370
 371         return undef unless (defined $searches);
 372
 373         for my $usr ( actor::user->search( $searches ) ) {
 374                 next unless $usr;
 375                 $client->respond( flesh_user( $usr ) );
 376         }
 377         return undef;
 378 }
 379 __PACKAGE__->register_method(
 380         api_name        => 'open-ils.storage.fleshed.actor.user.search',
 381         api_level       => 1,
 382         method          => 'fleshed_search',
 383         stream          => 1,
 384         cachable        => 1,
 385 );
 386
 387 sub fleshed_search_like {
 388         my $self = shift;
 389         my $client = shift;
 390         my $searches = shift;
 391
 392         return undef unless (defined $searches);
 393
 394         for my $usr ( actor::user->search_like( $searches ) ) {
 395                 next unless $usr;
 396                 $client->respond( flesh_user( $usr ) );
 397         }
 398         return undef;
 399 }
 400 __PACKAGE__->register_method(
 401         api_name        => 'open-ils.storage.fleshed.actor.user.search_like',
 402         api_level       => 1,
 403         method          => 'user_by_barcode',
 404         stream          => 1,
 405         cachable        => 1,
 406 );
 407
 408 sub retrieve_fleshed_user {
 409         my $self = shift;
 410         my $client = shift;
 411         my @ids = shift;
 412
 413         return undef unless @ids;
 414
 415         @ids = ($ids[0]) unless ($self->api_name =~ /batch/o);
 416
 417         $client->respond( flesh_user( actor::user->retrieve( $_ ) ) ) for ( @ids );
 418
 419         return undef;
 420 }
 421 __PACKAGE__->register_method(
 422         api_name        => 'open-ils.storage.fleshed.actor.user.retrieve',
 423         api_level       => 1,
 424         method          => 'retrieve_fleshed_user',
 425         cachable        => 1,
 426 );
 427 __PACKAGE__->register_method(
 428         api_name        => 'open-ils.storage.fleshed.actor.user.batch.retrieve',
 429         api_level       => 1,
 430         method          => 'retrieve_fleshed_user',
 431         stream          => 1,
 432         cachable        => 1,
 433 );
 434
 435 sub flesh_user {
 436         my $usr = shift;
 437
 438
 439         my $standing = $usr->standing;
 440         my $profile = $usr->profile;
 441         my $ident_type = $usr->ident_type;
 442
 443         my $maddress = $usr->mailing_address;
 444         my $baddress = $usr->billing_address;
 445         my $card = $usr->card;
 446
 447         my @addresses = $usr->addresses;
 448         my @cards = $usr->cards;
 449
 450         my $usr_fm = $usr->to_fieldmapper;
 451         $usr_fm->standing( $standing->to_fieldmapper );
 452         $usr_fm->profile( $profile->to_fieldmapper );
 453         $usr_fm->ident_type( $ident_type->to_fieldmapper );
 454
 455         $usr_fm->card( $card->to_fieldmapper );
 456         $usr_fm->mailing_address( $maddress->to_fieldmapper ) if ($maddress);
 457         $usr_fm->billing_address( $baddress->to_fieldmapper ) if ($baddress);
 458
 459         $usr_fm->cards( [ map { $_->to_fieldmapper } @cards ] );
 460         $usr_fm->addresses( [ map { $_->to_fieldmapper } @addresses ] );
 461
 462         return $usr_fm;
 463 }
 464
 465 =cut
 466
 467 sub org_unit_list {
 468         my $self = shift;
 469         my $client = shift;
 470
 471         my $select =<<" SQL";
 472         SELECT  *
 473           FROM  actor.org_unit
 474           ORDER BY CASE WHEN parent_ou IS NULL THEN 0 ELSE 1 END, name;
 475         SQL
 476
 477         my $sth = actor::org_unit->db_Main->prepare_cached($select);
 478         $sth->execute;
 479
 480         $client->respond( $_->to_fieldmapper ) for ( map { actor::org_unit->construct($_) } $sth->fetchall_hash );
 481
 482         return undef;
 483 }
 484 __PACKAGE__->register_method(
 485         api_name        => 'open-ils.storage.direct.actor.org_unit.retrieve.all',
 486         api_level       => 1,
 487         stream          => 1,
 488         method          => 'org_unit_list',
 489 );
 490
 491 sub org_unit_type_list {
 492         my $self = shift;
 493         my $client = shift;
 494
 495         my $select =<<" SQL";
 496         SELECT  *
 497           FROM  actor.org_unit_type
 498           ORDER BY depth, name;
 499         SQL
 500
 501         my $sth = actor::org_unit_type->db_Main->prepare_cached($select);
 502         $sth->execute;
 503
 504         $client->respond( $_->to_fieldmapper ) for ( map { actor::org_unit_type->construct($_) } $sth->fetchall_hash );
 505
 506         return undef;
 507 }
 508 __PACKAGE__->register_method(
 509         api_name        => 'open-ils.storage.direct.actor.org_unit_type.retrieve.all',
 510         api_level       => 1,
 511         stream          => 1,
 512         method          => 'org_unit_type_list',
 513 );
 514
 515 sub org_unit_full_path {
 516         my $self = shift;
 517         my $client = shift;
 518         my @binds = @_;
 519
 520         return undef unless (@binds);
 521
 522         my $func = 'actor.org_unit_full_path(?)';
 523         $func = 'actor.org_unit_full_path(?,?)' if (@binds > 1);
 524
 525         my $sth = actor::org_unit->db_Main->prepare_cached("SELECT * FROM $func");
 526         $sth->execute(@binds);
 527
 528         $client->respond( $_->to_fieldmapper ) for ( map { actor::org_unit->construct($_) } $sth->fetchall_hash );
 529
 530         return undef;
 531 }
 532 __PACKAGE__->register_method(
 533         api_name        => 'open-ils.storage.actor.org_unit.full_path',
 534         api_level       => 1,
 535         stream          => 1,
 536         method          => 'org_unit_full_path',
 537 );
 538
 539 sub org_unit_ancestors {
 540         my $self = shift;
 541         my $client = shift;
 542         my $id = shift;
 543
 544         return undef unless ($id);
 545
 546         my $func = 'actor.org_unit_ancestors(?)';
 547
 548         my $sth = actor::org_unit->db_Main->prepare_cached(<<"  SQL");
 549                 SELECT  f.*
 550                   FROM  $func f
 551                         JOIN actor.org_unit_type t ON (f.ou_type = t.id)
 552                   ORDER BY t.depth, f.name;
 553         SQL
 554         $sth->execute(''.$id);
 555
 556         $client->respond( $_->to_fieldmapper ) for ( map { actor::org_unit->construct($_) } $sth->fetchall_hash );
 557
 558         return undef;
 559 }
 560 __PACKAGE__->register_method(
 561         api_name        => 'open-ils.storage.actor.org_unit.ancestors',
 562         api_level       => 1,
 563         stream          => 1,
 564         method          => 'org_unit_ancestors',
 565 );
 566
 567 sub org_unit_descendants {
 568         my $self = shift;
 569         my $client = shift;
 570         my $id = shift;
 571         my $depth = shift;
 572
 573         return undef unless ($id);
 574
 575         my $func = 'actor.org_unit_descendants(?)';
 576         if (defined $depth) {
 577                 $func = 'actor.org_unit_descendants(?,?)';
 578         }
 579
 580         my $sth = actor::org_unit->db_Main->prepare_cached("SELECT * FROM $func");
 581         $sth->execute(''.$id, ''.$depth) if (defined $depth);
 582         $sth->execute(''.$id) unless (defined $depth);
 583
 584         $client->respond( $_->to_fieldmapper ) for ( map { actor::org_unit->construct($_) } $sth->fetchall_hash );
 585
 586         return undef;
 587 }
 588 __PACKAGE__->register_method(
 589         api_name        => 'open-ils.storage.actor.org_unit.descendants',
 590         api_level       => 1,
 591         stream          => 1,
 592         method          => 'org_unit_descendants',
 593 );
 594
 595 sub fleshed_actor_stat_cat {
 596         my $self = shift;
 597         my $client = shift;
 598         my @list = @_;
 599
 600         @list = ($list[0]) unless ($self->api_name =~ /batch/o);
 601
 602         for my $sc (@list) {
 603                 my $cat = actor::stat_cat->retrieve($sc);
 604                 next unless ($cat);
 605
 606                 my $sc_fm = $cat->to_fieldmapper;
 607                 $sc_fm->entries( [ map { $_->to_fieldmapper } $cat->entries ] );
 608
 609                 $client->respond( $sc_fm );
 610
 611         }
 612
 613         return undef;
 614 }
 615 __PACKAGE__->register_method(
 616         api_name        => 'open-ils.storage.fleshed.actor.stat_cat.retrieve',
 617         api_level       => 1,
 618         argc            => 1,
 619         method          => 'fleshed_actor_stat_cat',
 620 );
 621
 622 __PACKAGE__->register_method(
 623         api_name        => 'open-ils.storage.fleshed.actor.stat_cat.retrieve.batch',
 624         api_level       => 1,
 625         argc            => 1,
 626         stream          => 1,
 627         method          => 'fleshed_actor_stat_cat',
 628 );
 629
 630 #XXX Fix stored proc calls
 631 sub ranged_actor_stat_cat_all {
 632         my $self = shift;
 633         my $client = shift;
 634         my $ou = ''.shift();
 635
 636         return undef unless ($ou);
 637         my $s_table = actor::stat_cat->table;
 638
 639         my $select = <<"        SQL";
 640                 SELECT  s.*
 641                   FROM  $s_table s
 642                         JOIN actor.org_unit_full_path(?) p ON (p.id = s.owner)
 643                   ORDER BY name
 644         SQL
 645
 646         $fleshed = 0;
 647         $fleshed = 1 if ($self->api_name =~ /fleshed/o);
 648
 649         my $sth = actor::stat_cat->db_Main->prepare_cached($select);
 650         $sth->execute($ou);
 651
 652         for my $sc ( map { actor::stat_cat->construct($_) } $sth->fetchall_hash ) {
 653                 my $sc_fm = $sc->to_fieldmapper;
 654                 $sc_fm->entries(
 655                         [ $self->method_lookup( 'open-ils.storage.ranged.actor.stat_cat_entry.search.stat_cat' )->run($ou,$sc->id) ]
 656                 ) if ($fleshed);
 657                 $client->respond( $sc_fm );
 658         }
 659
 660         return undef;
 661 }
 662 __PACKAGE__->register_method(
 663         api_name        => 'open-ils.storage.ranged.fleshed.actor.stat_cat.all',
 664         api_level       => 1,
 665         argc            => 1,
 666         stream          => 1,
 667         method          => 'ranged_actor_stat_cat_all',
 668 );
 669
 670 __PACKAGE__->register_method(
 671         api_name        => 'open-ils.storage.ranged.actor.stat_cat.all',
 672         api_level       => 1,
 673         argc            => 1,
 674         stream          => 1,
 675         method          => 'ranged_actor_stat_cat_all',
 676 );
 677
 678 #XXX Fix stored proc calls
 679 sub ranged_actor_stat_cat_entry {
 680         my $self = shift;
 681         my $client = shift;
 682         my $ou = ''.shift();
 683         my $sc = ''.shift();
 684
 685         return undef unless ($ou);
 686         my $s_table = actor::stat_cat_entry->table;
 687
 688         my $select = <<"        SQL";
 689                 SELECT  s.*
 690                   FROM  $s_table s
 691                         JOIN actor.org_unit_full_path(?) p ON (p.id = s.owner)
 692                   WHERE stat_cat = ?
 693                   ORDER BY name
 694         SQL
 695
 696         my $sth = actor::stat_cat->db_Main->prepare_cached($select);
 697         $sth->execute($ou,$sc);
 698
 699         for my $sce ( map { actor::stat_cat_entry->construct($_) } $sth->fetchall_hash ) {
 700                 $client->respond( $sce->to_fieldmapper );
 701         }
 702
 703         return undef;
 704 }
 705 __PACKAGE__->register_method(
 706         api_name        => 'open-ils.storage.ranged.actor.stat_cat_entry.search.stat_cat',
 707         api_level       => 1,
 708         stream          => 1,
 709         method          => 'ranged_actor_stat_cat_entry',
 710 );
 711
 712
 713 1;