Open-ILS/src/perlmods/lib/OpenILS/Application/Circ/StatCat.pm

   1 # ---------------------------------------------------------------
   2 # Copyright (C) 2006  Georgia Public Library Service
   3 # Bill Erickson <billserickson@gmail.com>
   4
   5 # This program is free software; you can redistribute it and/or
   6 # modify it under the terms of the GNU General Public License
   7 # as published by the Free Software Foundation; either version 2
   8 # of the License, or (at your option) any later version.
   9
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 # ---------------------------------------------------------------
  15
  16 package OpenILS::Application::Circ::StatCat;
  17 use base qw/OpenILS::Application/;
  18 use strict; use warnings;
  19
  20 use OpenSRF::Utils::Logger qw($logger);
  21 use OpenSRF::EX qw/:try/;
  22 use OpenILS::Application::AppUtils;
  23 my $apputils = "OpenILS::Application::AppUtils";
  24 my $U = $apputils;
  25
  26
  27
  28 __PACKAGE__->register_method(
  29         method  => "retrieve_stat_cat_list",
  30         argc    => 1,
  31         api_name        => "open-ils.circ.stat_cat.actor.retrieve.batch");
  32
  33 __PACKAGE__->register_method(
  34         method  => "retrieve_stat_cat_list",
  35         argc    => 1,
  36         api_name        => "open-ils.circ.stat_cat.asset.retrieve.batch");
  37
  38 # retrieves all of the stat cats for a given org unit
  39 # if no orgid, user_session->home_ou is used
  40
  41 sub retrieve_stat_cat_list {
  42         my( $self, $client, $user_session, @sc ) = @_;
  43
  44         if (ref($sc[0])) {
  45                 @sc = @{$sc[0]};
  46         }
  47
  48         my $method = "open-ils.storage.fleshed.actor.stat_cat.retrieve.batch.atomic";
  49         if( $self->api_name =~ /asset/ ) {
  50                 $method = "open-ils.storage.fleshed.asset.stat_cat.retrieve.batch.atomic";
  51         }
  52
  53         my($user_obj, $evt) = $apputils->checkses($user_session);
  54     return $evt if $evt;
  55
  56         my $cats = $apputils->simple_scalar_request(
  57                                 "open-ils.storage", $method, @sc);
  58
  59         return [ sort { $a->name cmp $b->name } @$cats ];
  60 }
  61
  62 __PACKAGE__->register_method(
  63         method  => "retrieve_stat_cats",
  64         api_name        => "open-ils.circ.stat_cat.actor.retrieve.all");
  65
  66 __PACKAGE__->register_method(
  67         method  => "retrieve_stat_cats",
  68         api_name        => "open-ils.circ.stat_cat.asset.retrieve.all");
  69
  70 # retrieves all of the stat cats for a given org unit
  71 # if no orgid, user_session->home_ou is used
  72
  73 sub retrieve_stat_cats {
  74         my( $self, $client, $user_session, $orgid ) = @_;
  75
  76         my $method = "open-ils.storage.ranged.fleshed.actor.stat_cat.all.atomic";
  77         if( $self->api_name =~ /asset/ ) {
  78                 $method = "open-ils.storage.ranged.fleshed.asset.stat_cat.all.atomic";
  79         }
  80
  81         my($user_obj, $evt) = $apputils->checkses($user_session);
  82     return $evt if $evt;
  83
  84         if(!$orgid) { $orgid = $user_obj->home_ou; }
  85         my $cats = $apputils->simple_scalar_request(
  86                                 "open-ils.storage", $method, $orgid );
  87
  88         return [ sort { $a->name cmp $b->name } @$cats ];
  89 }
  90
  91
  92 __PACKAGE__->register_method(
  93         method  => "retrieve_ranged_intersect_stat_cats",
  94         api_name        => "open-ils.circ.stat_cat.asset.multirange.intersect.retrieve");
  95
  96 sub retrieve_ranged_intersect_stat_cats {
  97         my( $self, $client, $user_session, $orglist ) = @_;
  98
  99         my($user_obj, $evt) = $apputils->checkses($user_session);
 100     return $evt if $evt;
 101
 102         if(!$orglist) { $orglist = [ $user_obj->home_ou ]; }
 103
 104         # uniquify, yay!
 105         my %hash = map { ($_ => 1) } @$orglist;
 106         $orglist = [ keys %hash ];
 107
 108         warn "range: @$orglist\n";
 109
 110         my      $method = "open-ils.storage.multiranged.intersect.fleshed.asset.stat_cat.all.atomic";
 111         return $apputils->simple_scalar_request(
 112                                 "open-ils.storage", $method, $orglist );
 113 }
 114
 115
 116 __PACKAGE__->register_method(
 117         method  => "retrieve_ranged_union_stat_cats",
 118         api_name        => "open-ils.circ.stat_cat.asset.multirange.union.retrieve");
 119
 120 sub retrieve_ranged_union_stat_cats {
 121         my( $self, $client, $user_session, $orglist ) = @_;
 122
 123         my      $method = "open-ils.storage.multiranged.union.fleshed.asset.stat_cat.all.atomic";
 124         use Data::Dumper;
 125         warn "Retrieving stat_cats with method $method and orgs " . Dumper($orglist) . "\n";
 126
 127         my($user_obj, $evt) = $apputils->checkses($user_session);
 128     return $evt if $evt;
 129
 130         if(!$orglist) { $orglist = [ $user_obj->home_ou ]; }
 131
 132         # uniquify, yay!
 133         my %hash = map { ($_ => 1) } @$orglist;
 134         $orglist = [ keys %hash ];
 135
 136         warn "range: @$orglist\n";
 137
 138         return $apputils->simple_scalar_request(
 139                                 "open-ils.storage", $method, $orglist );
 140 }
 141
 142
 143
 144 __PACKAGE__->register_method(
 145         method  => "stat_cat_create",
 146         api_name        => "open-ils.circ.stat_cat.asset.create");
 147
 148 __PACKAGE__->register_method(
 149         method  => "stat_cat_create",
 150         api_name        => "open-ils.circ.stat_cat.actor.create");
 151
 152 sub stat_cat_create {
 153         my( $self, $client, $user_session, $stat_cat ) = @_;
 154
 155         my $method = "open-ils.storage.direct.actor.stat_cat.create";
 156         my $entry_create = "open-ils.storage.direct.actor.stat_cat_entry.create";
 157         my $perm = 'CREATE_PATRON_STAT_CAT';
 158         my $eperm = 'CREATE_PATRON_STAT_CAT_ENTRY';
 159
 160         if($self->api_name =~ /asset/) {
 161                 $method = "open-ils.storage.direct.asset.stat_cat.create";
 162                 $entry_create = "open-ils.storage.direct.asset.stat_cat_entry.create";
 163                 $perm = 'CREATE_COPY_STAT_CAT_ENTRY';
 164         }
 165
 166         #my $user_obj = $apputils->check_user_session($user_session);
 167         #my $orgid = $user_obj->home_ou();
 168         my( $user_obj, $evt ) = $apputils->checkses($user_session);
 169         return $evt if $evt;
 170         $evt = $apputils->check_perms($user_obj->id, $stat_cat->owner, $perm);
 171         return $evt if $evt;
 172
 173         if($stat_cat->entries) {
 174                 $evt = $apputils->check_perms($user_obj->id, $stat_cat->owner, $eperm);
 175                 return $evt if $evt;
 176         }
 177
 178
 179         my $session = $apputils->start_db_session();
 180         $apputils->set_audit_info($session, $user_session, $user_obj->id, $user_obj->wsid);
 181         my $newid = _create_stat_cat($session, $stat_cat, $method);
 182
 183         if( ref($stat_cat->entries) ) {
 184                 for my $entry (@{$stat_cat->entries}) {
 185                         $entry->stat_cat($newid);
 186                         _create_stat_entry($session, $entry, $entry_create);
 187                 }
 188         }
 189
 190         $apputils->commit_db_session($session);
 191
 192         $logger->debug("Stat cat creation successful with id $newid");
 193
 194         my $orgid = $user_obj->home_ou;
 195         if( $self->api_name =~ /asset/ ) {
 196                 return _flesh_asset_cat($newid, $orgid);
 197         } else {
 198                 return _flesh_user_cat($newid, $orgid);
 199         }
 200 }
 201
 202
 203 sub _flesh_user_cat {
 204         my $id = shift;
 205         my $orgid = shift;
 206
 207         my $session = OpenSRF::AppSession->create("open-ils.storage");
 208         my $cat = $session->request(
 209                 "open-ils.storage.direct.actor.stat_cat.retrieve",
 210                 $id )->gather(1);
 211
 212         $cat->entries(
 213                 $session->request(
 214                         "open-ils.storage.ranged.actor.stat_cat_entry.search.stat_cat.atomic",
 215                         $orgid, $id )->gather(1) );
 216
 217         return $cat;
 218 }
 219
 220
 221 sub _flesh_asset_cat {
 222         my $id = shift;
 223         my $orgid = shift;
 224
 225         my $session = OpenSRF::AppSession->create("open-ils.storage");
 226         my $cat = $session->request(
 227                 "open-ils.storage.direct.asset.stat_cat.retrieve",
 228                 $id )->gather(1);
 229
 230         $cat->entries(
 231                 $session->request(
 232                         "open-ils.storage.ranged.asset.stat_cat_entry.search.stat_cat.atomic",
 233                         $orgid,  $id )->gather(1) );
 234
 235         return $cat;
 236
 237 }
 238
 239
 240 sub _create_stat_cat {
 241         my( $session, $stat_cat, $method) = @_;
 242         warn "Creating new stat cat with name " . $stat_cat->name . "\n";
 243         $stat_cat->clear_id();
 244         my $req = $session->request( $method, $stat_cat );
 245         my $id = $req->gather(1);
 246         if(!$id) {
 247                 throw OpenSRF::EX::ERROR
 248                 ("Error creating new statistical category"); }
 249
 250         warn "Stat cat create returned id $id\n";
 251         return $id;
 252 }
 253
 254
 255 sub _create_stat_entry {
 256         my( $session, $stat_entry, $method) = @_;
 257
 258         warn "Creating new stat entry with value " . $stat_entry->value . "\n";
 259         $stat_entry->clear_id();
 260
 261         my $req = $session->request($method, $stat_entry);
 262         my $id = $req->gather(1);
 263
 264         warn "Stat entry " . Dumper($stat_entry) . "\n";
 265
 266         if(!$id) {
 267                 throw OpenSRF::EX::ERROR
 268                 ("Error creating new stat cat entry"); }
 269
 270         warn "Stat cat entry create returned id $id\n";
 271         return $id;
 272 }
 273
 274
 275 __PACKAGE__->register_method(
 276         method  => "update_stat_entry",
 277         api_name        => "open-ils.circ.stat_cat.actor.entry.update");
 278
 279 __PACKAGE__->register_method(
 280         method  => "update_stat_entry",
 281         api_name        => "open-ils.circ.stat_cat.asset.entry.update");
 282
 283 sub update_stat_entry {
 284         my( $self, $client, $user_session, $entry ) = @_;
 285
 286
 287         my $method = "open-ils.storage.direct.actor.stat_cat_entry.update";
 288         my $perm = 'UPDATE_PATRON_STAT_CAT_ENTRY';
 289         if($self->api_name =~ /asset/) {
 290                 $method = "open-ils.storage.direct.asset.stat_cat_entry.update";
 291                 $perm = 'UPDATE_COPY_STAT_CAT_ENTRY';
 292         }
 293
 294         my( $user_obj, $evt )  = $apputils->checkses($user_session);
 295         return $evt if $evt;
 296         $evt = $apputils->check_perms( $user_obj->id, $entry->owner, $perm );
 297         return $evt if $evt;
 298
 299         my $session = $apputils->start_db_session();
 300         $apputils->set_audit_info($session, $user_session, $user_obj->id, $user_obj->wsid);
 301         my $req = $session->request($method, $entry);
 302         my $status = $req->gather(1);
 303         $apputils->commit_db_session($session);
 304         warn "stat cat entry with value " . $entry->value . " updated with status $status\n";
 305         return 1;
 306 }
 307
 308
 309 __PACKAGE__->register_method(
 310         method  => "update_stat",
 311         api_name        => "open-ils.circ.stat_cat.actor.update");
 312
 313 __PACKAGE__->register_method(
 314         method  => "update_stat",
 315         api_name        => "open-ils.circ.stat_cat.asset.update");
 316
 317 sub update_stat {
 318         my( $self, $client, $user_session, $cat ) = @_;
 319
 320         my $method = "open-ils.storage.direct.actor.stat_cat.update";
 321         my $perm = 'UPDATE_PATRON_STAT_CAT';
 322         if($self->api_name =~ /asset/) {
 323                 $method = "open-ils.storage.direct.asset.stat_cat.update";
 324                 $perm = 'UPDATE_COPY_STAT_CAT';
 325         }
 326
 327         my( $user_obj, $evt )  = $apputils->checkses($user_session);
 328         return $evt if $evt;
 329         $evt = $apputils->check_perms( $user_obj->id, $cat->owner, $perm );
 330         return $evt if $evt;
 331
 332         my $session = $apputils->start_db_session();
 333         $apputils->set_audit_info($session, $user_session, $user_obj->id, $user_obj->wsid);
 334         my $req = $session->request($method, $cat);
 335         my $status = $req->gather(1);
 336         $apputils->commit_db_session($session);
 337         warn "stat cat with id " . $cat->id . " updated with status $status\n";
 338         return 1;
 339 }
 340
 341
 342 __PACKAGE__->register_method(
 343         method  => "create_stat_entry",
 344         api_name        => "open-ils.circ.stat_cat.actor.entry.create");
 345
 346 __PACKAGE__->register_method(
 347         method  => "create_stat_entry",
 348         api_name        => "open-ils.circ.stat_cat.asset.entry.create");
 349
 350 sub create_stat_entry {
 351         my( $self, $client, $user_session, $entry ) = @_;
 352
 353         my $method = "open-ils.storage.direct.actor.stat_cat_entry.create";
 354         my $perm = 'CREATE_PATRON_STAT_CAT_ENTRY';
 355         if($self->api_name =~ /asset/) {
 356                 $method = "open-ils.storage.direct.asset.stat_cat_entry.create";
 357                 $perm = 'CREATE_COPY_STAT_CAT_ENTRY';
 358         }
 359
 360         my( $user_obj, $evt )  = $apputils->checkses($user_session);
 361         return $evt if $evt;
 362         $evt = $apputils->check_perms( $user_obj->id, $entry->owner, $perm );
 363         return $evt if $evt;
 364
 365         $entry->clear_id();
 366         my $session = $apputils->start_db_session();
 367         $apputils->set_audit_info($session, $user_session, $user_obj->id, $user_obj->wsid);
 368         my $req = $session->request($method, $entry);
 369         my $status = $req->gather(1);
 370         $apputils->commit_db_session($session);
 371
 372         $logger->info("created stat cat entry $status");
 373         return $status;
 374 }
 375
 376
 377
 378 __PACKAGE__->register_method(
 379         method  => "create_stat_map",
 380         api_name        => "open-ils.circ.stat_cat.actor.user_map.create");
 381
 382 __PACKAGE__->register_method(
 383         method  => "create_stat_map",
 384         api_name        => "open-ils.circ.stat_cat.asset.copy_map.create");
 385
 386 sub create_stat_map {
 387         my( $self, $client, $user_session, $map ) = @_;
 388
 389
 390         my ( $evt, $copy, $volume, $patron, $user_obj );
 391
 392         my $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.create";
 393         my $ret = "open-ils.storage.direct.actor.stat_cat_entry_user_map.retrieve";
 394         my $perm = 'CREATE_PATRON_STAT_CAT_ENTRY_MAP';
 395         my $perm_org;
 396
 397         if($self->api_name =~ /asset/) {
 398                 $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.create";
 399                 $ret = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.retrieve";
 400                 $perm = 'CREATE_COPY_STAT_CAT_ENTRY_MAP';
 401                 ( $copy, $evt ) = $apputils->fetch_copy($map->owning_copy);
 402                 return $evt if $evt;
 403                 ( $volume, $evt ) = $apputils->fetch_callnumber($copy->call_number);
 404                 return $evt if $evt;
 405                 $perm_org = $volume->owning_lib;
 406
 407         } else {
 408                 ($patron, $evt) = $apputils->fetch_user($map->target_usr);
 409                 return $evt if $evt;
 410                 $perm_org = $patron->home_ou;
 411         }
 412
 413         ( $user_obj, $evt )  = $apputils->checkses($user_session);
 414         return $evt if $evt;
 415         $evt = $apputils->check_perms( $user_obj->id, $perm_org, $perm );
 416         return $evt if $evt;
 417
 418         $logger->debug( $user_obj->id . " creating new stat cat map" );
 419
 420         $map->clear_id();
 421
 422         my $session = $apputils->start_db_session();
 423         $apputils->set_audit_info($session, $user_session, $user_obj->id, $user_obj->wsid);
 424         my $req = $session->request($method, $map);
 425         my $newid = $req->gather(1);
 426         warn "Created new stat cat map with id $newid\n";
 427         $apputils->commit_db_session($session);
 428
 429         return $apputils->simple_scalar_request( "open-ils.storage", $ret, $newid );
 430
 431 }
 432
 433
 434 __PACKAGE__->register_method(
 435         method  => "update_stat_map",
 436         api_name        => "open-ils.circ.stat_cat.actor.user_map.update");
 437
 438 __PACKAGE__->register_method(
 439         method  => "update_stat_map",
 440         api_name        => "open-ils.circ.stat_cat.asset.copy_map.update");
 441
 442 sub update_stat_map {
 443         my( $self, $client, $user_session, $map ) = @_;
 444
 445         my ( $evt, $copy, $volume, $patron, $user_obj );
 446
 447         my $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.update";
 448         my $perm = 'UPDATE_PATRON_STAT_ENTRY_MAP';
 449         my $perm_org;
 450
 451         if($self->api_name =~ /asset/) {
 452                 $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.update";
 453                 $perm = 'UPDATE_COPY_STAT_ENTRY_MAP';
 454                 ( $copy, $evt ) = $apputils->fetch_copy($map->owning_copy);
 455                 return $evt if $evt;
 456                 ( $volume, $evt ) = $apputils->fetch_callnumber($copy->call_number);
 457                 return $evt if $evt;
 458                 $perm_org = $volume->owning_lib;
 459
 460         } else {
 461                 ($patron, $evt) = $apputils->fetch_user($map->target_usr);
 462                 return $evt if $evt;
 463                 $perm_org = $patron->home_ou;
 464         }
 465
 466
 467         ( $user_obj, $evt )  = $apputils->checkses($user_session);
 468         return $evt if $evt;
 469         $evt = $apputils->check_perms( $user_obj->id, $perm_org, $perm );
 470         return $evt if $evt;
 471
 472
 473         my $session = $apputils->start_db_session();
 474         $apputils->set_audit_info($session, $user_session, $user_obj->id, $user_obj->wsid);
 475         my $req = $session->request($method, $map);
 476         my $newid = $req->gather(1);
 477         warn "Updated new stat cat map with id $newid\n";
 478         $apputils->commit_db_session($session);
 479
 480         return $newid;
 481 }
 482
 483
 484
 485 __PACKAGE__->register_method(
 486         method  => "retrieve_maps",
 487         api_name        => "open-ils.circ.stat_cat.actor.user_map.retrieve");
 488
 489 __PACKAGE__->register_method(
 490         method  => "retrieve_maps",
 491         api_name        => "open-ils.circ.stat_cat.asset.copy_map.retrieve");
 492
 493 sub retrieve_maps {
 494         my( $self, $client, $user_session, $target ) = @_;
 495
 496
 497         my( $user_obj, $evt ) = $apputils->checkses($user_session);
 498         return $evt if $evt;
 499
 500         my      $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.search.owning_copy.atomic";
 501         if($self->api_name =~ /actor/ ) {
 502                 if(!$target) { $target = $user_obj->id; }
 503                 $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.search.target_usr.atomic";
 504         }
 505
 506         return $apputils->simple_scalar_request("open-ils.storage", $method, $target);
 507 }
 508
 509
 510
 511
 512 __PACKAGE__->register_method(
 513         method  => "delete_stats",
 514         api_name        => "open-ils.circ.stat_cat.actor.delete");
 515
 516 __PACKAGE__->register_method(
 517         method  => "delete_stats",
 518         api_name        => "open-ils.circ.stat_cat.asset.delete");
 519
 520 sub delete_stats {
 521         my( $self, $client, $user_session, $target ) = @_;
 522
 523         my $cat;
 524
 525         my $type = "actor";
 526         my $perm = 'DELETE_PATRON_STAT_CAT';
 527         if($self->api_name =~ /asset/) {
 528                 $type = "asset";
 529                 $perm = 'DELETE_COPY_STAT_CAT';
 530         }
 531
 532         my( $user_obj, $evt )  = $apputils->checkses($user_session);
 533         return $evt if $evt;
 534
 535         ( $cat, $evt ) = $apputils->fetch_stat_cat( $type, $target );
 536         return $evt if $evt;
 537
 538         $evt = $apputils->check_perms( $user_obj->id, $cat->owner, $perm );
 539         return $evt if $evt;
 540
 541         my $session = OpenSRF::AppSession->create("open-ils.storage");
 542         return _delete_stats($session, $target, $type);
 543 }
 544
 545 sub _delete_stats {
 546         my( $session, $stat, $type) = @_;
 547
 548         my      $method = "open-ils.storage.direct.asset.stat_cat.delete";
 549         if($type =~ /actor/ ) {
 550                 $method = "open-ils.storage.direct.actor.stat_cat.delete";
 551         }
 552         return $session->request($method, $stat)->gather(1);
 553 }
 554
 555
 556
 557 __PACKAGE__->register_method(
 558         method  => "delete_entry",
 559         api_name        => "open-ils.circ.stat_cat.actor.entry.delete");
 560
 561 __PACKAGE__->register_method(
 562         method  => "delete_entry",
 563         api_name        => "open-ils.circ.stat_cat.asset.entry.delete");
 564
 565 sub delete_entry {
 566         my( $self, $client, $user_session, $target ) = @_;
 567
 568         my $type = "actor";
 569         my $perm = 'DELETE_PATRON_STAT_CAT_ENTRY';
 570         if($self->api_name =~ /asset/) {
 571                 $type = "asset";
 572                 $perm = 'DELETE_COPY_STAT_CAT_ENTRY';
 573         }
 574
 575         my $entry;
 576         my( $user_obj, $evt )  = $apputils->checkses($user_session);
 577         return $evt if $evt;
 578
 579         ( $entry, $evt ) = $apputils->fetch_stat_cat_entry( $type, $target );
 580         return $evt if $evt;
 581
 582         $evt = $apputils->check_perms( $user_obj->id, $entry->owner, $perm );
 583         return $evt if $evt;
 584
 585         my $session = OpenSRF::AppSession->create("open-ils.storage");
 586         return _delete_entry($session, $target, $type);
 587 }
 588
 589 sub _delete_entry {
 590         my( $session, $stat_entry, $type) = @_;
 591
 592         my      $method = "open-ils.storage.direct.asset.stat_cat_entry.delete";
 593         if($type =~ /actor/ ) {
 594                 $method = "open-ils.storage.direct.actor.stat_cat_entry.delete";
 595         }
 596
 597         return $session->request($method, $stat_entry)->gather(1);
 598 }
 599
 600
 601 __PACKAGE__->register_method(
 602         method => 'fetch_stats_by_copy',
 603         api_name        => 'open-ils.circ.asset.stat_cat_entries.fleshed.retrieve_by_copy',
 604 );
 605
 606
 607 sub fetch_stats_by_copy {
 608         my( $self, $conn, $args ) = @_;
 609
 610         my @entries;
 611
 612         if( $$args{public} ) {
 613                 my $maps = $U->cstorereq(
 614                         'open-ils.cstore.direct.asset.stat_cat_entry_copy_map.search.atomic', { owning_copy => $$args{copyid} });
 615
 616
 617                 warn "here\n";
 618                 for my $map (@$maps) {
 619
 620                         warn "map ".$map->id."\n";
 621                         warn "map ".$map->stat_cat_entry."\n";
 622
 623                         my $entry = $U->cstorereq(
 624                                 'open-ils.cstore.direct.asset.stat_cat_entry.retrieve', $map->stat_cat_entry);
 625
 626                         warn "Found entry ".$entry->id."\n";
 627
 628                         my $cat = $U->cstorereq(
 629                                 'open-ils.cstore.direct.asset.stat_cat.retrieve', $entry->stat_cat );
 630                         $entry->stat_cat( $cat );
 631                         push( @entries, $entry );
 632                 }
 633         }
 634
 635         return \@entries;
 636 }
 637
 638
 639
 640 1;