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 $default_entry_create = "open-ils.storage.direct.actor.stat_cat_entry_default.create";
 158     my $perm = 'CREATE_PATRON_STAT_CAT';
 159     my $eperm = 'CREATE_PATRON_STAT_CAT_ENTRY';
 160     my $edperm = 'CREATE_PATRON_STAT_CAT_ENTRY_DEFAULT';
 161
 162     if($self->api_name =~ /asset/) {
 163         $method = "open-ils.storage.direct.asset.stat_cat.create";
 164         $entry_create = "open-ils.storage.direct.asset.stat_cat_entry.create";
 165         $perm = 'CREATE_COPY_STAT_CAT_ENTRY';
 166     }
 167
 168     #my $user_obj = $apputils->check_user_session($user_session);
 169     #my $orgid = $user_obj->home_ou();
 170     my( $user_obj, $evt ) = $apputils->checkses($user_session);
 171     return $evt if $evt;
 172     $evt = $apputils->check_perms($user_obj->id, $stat_cat->owner, $perm);
 173     return $evt if $evt;
 174
 175     if($stat_cat->entries) {
 176         $evt = $apputils->check_perms($user_obj->id, $stat_cat->owner, $eperm);
 177         return $evt if $evt;
 178     }
 179
 180
 181     my $session = $apputils->start_db_session();
 182     $apputils->set_audit_info($session, $user_session, $user_obj->id, $user_obj->wsid);
 183     my $newid = _create_stat_cat($session, $stat_cat, $method);
 184
 185     if( ref($stat_cat->entries) ) {
 186         for my $entry (@{$stat_cat->entries}) {
 187             $entry->stat_cat($newid);
 188             my $entry_id = _create_stat_entry($session, $entry, $entry_create);
 189             if( $self->api_name =~ /actor/ && ref($entry->default_entries) ) {
 190                 $evt = $apputils->check_perms($user_obj->id, $stat_cat->owner, $edperm);
 191                 return $evt if $evt;
 192
 193                 for my $default_entry (@{$entry->default_entries}) {
 194                     $default_entry->stat_cat_entry($entry_id);
 195                     _create_stat_entry_default($session, $default_entry, $default_entry_create);
 196                 }
 197             }
 198         }
 199     }
 200
 201     $apputils->commit_db_session($session);
 202
 203     $logger->debug("Stat cat creation successful with id $newid");
 204
 205     my $orgid = $user_obj->home_ou;
 206     if( $self->api_name =~ /asset/ ) {
 207         return _flesh_asset_cat($newid, $orgid);
 208     } else {
 209         return _flesh_user_cat($newid, $orgid);
 210     }
 211 }
 212
 213
 214 sub _flesh_user_cat {
 215     my $id = shift;
 216     my $orgid = shift;
 217
 218     my $session = OpenSRF::AppSession->create("open-ils.storage");
 219     my $cat = $session->request(
 220         "open-ils.storage.direct.actor.stat_cat.retrieve",
 221         $id )->gather(1);
 222
 223     $cat->entries(
 224         $session->request(
 225             "open-ils.storage.ranged.actor.stat_cat_entry.search.stat_cat.atomic",
 226             $orgid, $id )->gather(1) );
 227
 228     return $cat;
 229 }
 230
 231
 232 sub _flesh_asset_cat {
 233     my $id = shift;
 234     my $orgid = shift;
 235
 236     my $session = OpenSRF::AppSession->create("open-ils.storage");
 237     my $cat = $session->request(
 238         "open-ils.storage.direct.asset.stat_cat.retrieve",
 239         $id )->gather(1);
 240
 241     $cat->entries(
 242         $session->request(
 243             "open-ils.storage.ranged.asset.stat_cat_entry.search.stat_cat.atomic",
 244             $orgid,  $id )->gather(1) );
 245
 246     return $cat;
 247
 248 }
 249
 250
 251 sub _create_stat_cat {
 252     my( $session, $stat_cat, $method) = @_;
 253     warn "Creating new stat cat with name " . $stat_cat->name . "\n";
 254     $stat_cat->clear_id();
 255     my $req = $session->request( $method, $stat_cat );
 256     my $id = $req->gather(1);
 257     if(!$id) {
 258         throw OpenSRF::EX::ERROR
 259         ("Error creating new statistical category"); }
 260
 261     warn "Stat cat create returned id $id\n";
 262     return $id;
 263 }
 264
 265
 266 sub _create_stat_entry {
 267     my( $session, $stat_entry, $method) = @_;
 268
 269     warn "Creating new stat entry with value " . $stat_entry->value . "\n";
 270     $stat_entry->clear_id();
 271
 272     my $req = $session->request($method, $stat_entry);
 273     my $id = $req->gather(1);
 274
 275     warn "Stat entry " . Dumper($stat_entry) . "\n";
 276
 277     if(!$id) {
 278         throw OpenSRF::EX::ERROR
 279         ("Error creating new stat cat entry"); }
 280
 281     warn "Stat cat entry create returned id $id\n";
 282     return $id;
 283 }
 284
 285
 286 __PACKAGE__->register_method(
 287     method  => "update_stat_entry",
 288     api_name    => "open-ils.circ.stat_cat.actor.entry.update");
 289
 290 __PACKAGE__->register_method(
 291     method  => "update_stat_entry",
 292     api_name    => "open-ils.circ.stat_cat.asset.entry.update");
 293
 294 sub update_stat_entry {
 295     my( $self, $client, $user_session, $entry ) = @_;
 296
 297
 298     my $method = "open-ils.storage.direct.actor.stat_cat_entry.update";
 299     my $perm = 'UPDATE_PATRON_STAT_CAT_ENTRY';
 300     if($self->api_name =~ /asset/) {
 301         $method = "open-ils.storage.direct.asset.stat_cat_entry.update";
 302         $perm = 'UPDATE_COPY_STAT_CAT_ENTRY';
 303     }
 304
 305     my( $user_obj, $evt )  = $apputils->checkses($user_session);
 306     return $evt if $evt;
 307     $evt = $apputils->check_perms( $user_obj->id, $entry->owner, $perm );
 308     return $evt if $evt;
 309
 310     my $session = $apputils->start_db_session();
 311     $apputils->set_audit_info($session, $user_session, $user_obj->id, $user_obj->wsid);
 312     my $req = $session->request($method, $entry);
 313     my $status = $req->gather(1);
 314     $apputils->commit_db_session($session);
 315     warn "stat cat entry with value " . $entry->value . " updated with status $status\n";
 316     return 1;
 317 }
 318
 319 sub _update_stat_entry_default {
 320     my( $session, $default_entry, $method) = @_;
 321
 322     warn "Updating new default stat entry for stat_cat " . $default_entry->stat_cat .
 323         " for org unit " . $default_entry->owner .
 324         " with new entry id " . $default_entry->stat_cat_entry . "\n";
 325
 326     my $req = $session->request($method, $default_entry);
 327     my $status = $req->gather(1);
 328
 329     warn "Default stat entry " . Dumper($default_entry) . "\n";
 330
 331     if(!$status) {
 332         throw OpenSRF::EX::ERROR
 333         ("Error updating default stat cat entry"); }
 334
 335     warn "Default stat cat entry update returned status $status\n";
 336     return $status;
 337 }
 338
 339 __PACKAGE__->register_method(
 340     method  => "update_stat",
 341     api_name    => "open-ils.circ.stat_cat.actor.update");
 342
 343 __PACKAGE__->register_method(
 344     method  => "update_stat",
 345     api_name    => "open-ils.circ.stat_cat.asset.update");
 346
 347 sub update_stat {
 348     my( $self, $client, $user_session, $cat ) = @_;
 349
 350     my $method = "open-ils.storage.direct.actor.stat_cat.update";
 351     my $perm = 'UPDATE_PATRON_STAT_CAT';
 352     if($self->api_name =~ /asset/) {
 353         $method = "open-ils.storage.direct.asset.stat_cat.update";
 354         $perm = 'UPDATE_COPY_STAT_CAT';
 355     }
 356
 357     my( $user_obj, $evt )  = $apputils->checkses($user_session);
 358     return $evt if $evt;
 359     $evt = $apputils->check_perms( $user_obj->id, $cat->owner, $perm );
 360     return $evt if $evt;
 361
 362     my $session = $apputils->start_db_session();
 363     $apputils->set_audit_info($session, $user_session, $user_obj->id, $user_obj->wsid);
 364     my $req = $session->request($method, $cat);
 365     my $status = $req->gather(1);
 366     $apputils->commit_db_session($session);
 367     warn "stat cat with id " . $cat->id . " updated with status $status\n";
 368     return 1;
 369 }
 370
 371
 372 __PACKAGE__->register_method(
 373     method  => "create_stat_entry",
 374     api_name    => "open-ils.circ.stat_cat.actor.entry.create");
 375
 376 __PACKAGE__->register_method(
 377     method  => "create_stat_entry",
 378     api_name    => "open-ils.circ.stat_cat.asset.entry.create");
 379
 380 sub create_stat_entry {
 381     my( $self, $client, $user_session, $entry ) = @_;
 382
 383     my $method = "open-ils.storage.direct.actor.stat_cat_entry.create";
 384     my $default_entry_create = "open-ils.storage.direct.actor.stat_cat_entry_default.create";
 385     my $default_entry_update = "open-ils.storage.direct.actor.stat_cat_entry_default.update";
 386     my $perm = 'CREATE_PATRON_STAT_CAT_ENTRY';
 387     my $edperm = 'CREATE_PATRON_STAT_CAT_ENTRY_DEFAULT';
 388     my $edperm_update = 'UPDATE_PATRON_STAT_CAT_ENTRY_DEFAULT';
 389     my $type = 'actor';
 390     if($self->api_name =~ /asset/) {
 391         $method = "open-ils.storage.direct.asset.stat_cat_entry.create";
 392         $perm = 'CREATE_COPY_STAT_CAT_ENTRY';
 393         $type = 'asset';
 394     }
 395
 396     my( $user_obj, $evt )  = $apputils->checkses($user_session);
 397     return $evt if $evt;
 398     $evt = $apputils->check_perms( $user_obj->id, $entry->owner, $perm );
 399     return $evt if $evt;
 400
 401     my $session = $apputils->start_db_session();
 402     $apputils->set_audit_info($session, $user_session, $user_obj->id, $user_obj->wsid);
 403     my $newid = _create_stat_entry($session, $entry, $method);
 404
 405     if( $self->api_name =~ /actor/ && ref($entry->default_entries) ) {
 406         $evt = $apputils->check_perms($user_obj->id, $entry->owner, $edperm);
 407         return $evt if $evt;
 408
 409         for my $default_entry (@{$entry->default_entries}) {
 410             $default_entry->stat_cat_entry($newid);
 411             my $target;
 412             ($target, $evt) = $apputils->fetch_stat_cat_entry_default_by_stat_cat_and_org($type,
 413                                                     $default_entry->stat_cat,
 414                                                     $default_entry->owner);
 415             if( $target ) {
 416                 $evt = $apputils->check_perms($user_obj->id, $default_entry->owner, $edperm_update);
 417                 return $evt if $evt;
 418                 $target->stat_cat_entry($newid);
 419                 _update_stat_entry_default($session, $target, $default_entry_update);
 420             } else {
 421                 _create_stat_entry_default($session, $default_entry, $default_entry_create);
 422             }
 423         }
 424     }
 425
 426     $apputils->commit_db_session($session);
 427
 428     $logger->info("created stat cat entry $newid");
 429
 430     return $newid;
 431 }
 432
 433 __PACKAGE__->register_method(
 434     method => "create_stat_entry_default",
 435     api_name => "open-ils.circ.stat_cat.actor.entry.default.create");
 436
 437
 438 sub create_stat_entry_default {
 439     my( $self, $client, $user_session, $default_entry ) = @_;
 440
 441     my $create_method = "open-ils.storage.direct.actor.stat_cat_entry_default.create";
 442     my $update_method = "open-ils.storage.direct.actor.stat_cat_entry_default.update";
 443     my $create_perm = 'UPDATE_PATRON_STAT_CAT_ENTRY_DEFAULT';
 444     my $update_perm = 'CREATE_PATRON_STAT_CAT_ENTRY_DEFAULT';
 445     my $type = 'actor';
 446     my ($target, $id);
 447
 448     my( $user_obj, $evt )  = $apputils->checkses($user_session);
 449     return $evt if $evt;
 450
 451     my $session = $apputils->start_db_session();
 452
 453     ($target, $evt) = $apputils->fetch_stat_cat_entry_default_by_stat_cat_and_org(
 454         $type,
 455         $default_entry->stat_cat,
 456         $default_entry->owner);
 457     if( $target ) {
 458         $evt = $apputils->check_perms($user_obj->id, $default_entry->owner, $update_perm);
 459         return $evt if $evt;
 460         $id = $target->id;
 461         $default_entry->id($id);
 462         _update_stat_entry_default($session, $default_entry, $update_method);
 463         $logger->info("updated stat cat default entry $id");
 464     } else {
 465         $evt = $apputils->check_perms($user_obj->id, $default_entry->owner, $create_perm);
 466         return $evt if $evt;
 467         $id = _create_stat_entry_default($session, $default_entry, $create_method);
 468         $logger->info("created stat cat default entry $id");
 469     }
 470
 471     $apputils->commit_db_session($session);
 472
 473     return $id;
 474 }
 475
 476 sub _create_stat_entry_default {
 477     my( $session, $stat_entry_default, $method) = @_;
 478
 479     warn "Creating new default stat entry for stat_cat " . $stat_entry_default->stat_cat . "\n";
 480     $stat_entry_default->clear_id();
 481
 482     my $req = $session->request($method, $stat_entry_default);
 483     my $id = $req->gather(1);
 484
 485     warn "Default stat entry " . Dumper($stat_entry_default) . "\n";
 486
 487     if(!$id) {
 488         throw OpenSRF::EX::ERROR
 489         ("Error creating new default stat cat entry"); }
 490
 491     warn "Default stat cat entry create returned id $id\n";
 492     return $id;
 493 }
 494
 495 __PACKAGE__->register_method(
 496     method  => "create_stat_map",
 497     api_name    => "open-ils.circ.stat_cat.actor.user_map.create");
 498
 499 __PACKAGE__->register_method(
 500     method  => "create_stat_map",
 501     api_name    => "open-ils.circ.stat_cat.asset.copy_map.create");
 502
 503 sub create_stat_map {
 504     my( $self, $client, $user_session, $map ) = @_;
 505
 506
 507     my ( $evt, $copy, $volume, $patron, $user_obj );
 508
 509     my $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.create";
 510     my $ret = "open-ils.storage.direct.actor.stat_cat_entry_user_map.retrieve";
 511     my $perm = 'CREATE_PATRON_STAT_CAT_ENTRY_MAP';
 512     my $perm_org;
 513
 514     if($self->api_name =~ /asset/) {
 515         $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.create";
 516         $ret = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.retrieve";
 517         $perm = 'CREATE_COPY_STAT_CAT_ENTRY_MAP';
 518         ( $copy, $evt ) = $apputils->fetch_copy($map->owning_copy);
 519         return $evt if $evt;
 520         ( $volume, $evt ) = $apputils->fetch_callnumber($copy->call_number);
 521         return $evt if $evt;
 522         $perm_org = $volume->owning_lib;
 523
 524     } else {
 525         ($patron, $evt) = $apputils->fetch_user($map->target_usr);
 526         return $evt if $evt;
 527         $perm_org = $patron->home_ou;
 528     }
 529
 530     ( $user_obj, $evt )  = $apputils->checkses($user_session);
 531     return $evt if $evt;
 532     $evt = $apputils->check_perms( $user_obj->id, $perm_org, $perm );
 533     return $evt if $evt;
 534
 535     $logger->debug( $user_obj->id . " creating new stat cat map" );
 536
 537     $map->clear_id();
 538
 539     my $session = $apputils->start_db_session();
 540     $apputils->set_audit_info($session, $user_session, $user_obj->id, $user_obj->wsid);
 541     my $req = $session->request($method, $map);
 542     my $newid = $req->gather(1);
 543     warn "Created new stat cat map with id $newid\n";
 544     $apputils->commit_db_session($session);
 545
 546     return $apputils->simple_scalar_request( "open-ils.storage", $ret, $newid );
 547
 548 }
 549
 550
 551 __PACKAGE__->register_method(
 552     method  => "update_stat_map",
 553     api_name    => "open-ils.circ.stat_cat.actor.user_map.update");
 554
 555 __PACKAGE__->register_method(
 556     method  => "update_stat_map",
 557     api_name    => "open-ils.circ.stat_cat.asset.copy_map.update");
 558
 559 sub update_stat_map {
 560     my( $self, $client, $user_session, $map ) = @_;
 561
 562     my ( $evt, $copy, $volume, $patron, $user_obj );
 563
 564     my $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.update";
 565     my $perm = 'UPDATE_PATRON_STAT_ENTRY_MAP';
 566     my $perm_org;
 567
 568     if($self->api_name =~ /asset/) {
 569         $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.update";
 570         $perm = 'UPDATE_COPY_STAT_ENTRY_MAP';
 571         ( $copy, $evt ) = $apputils->fetch_copy($map->owning_copy);
 572         return $evt if $evt;
 573         ( $volume, $evt ) = $apputils->fetch_callnumber($copy->call_number);
 574         return $evt if $evt;
 575         $perm_org = $volume->owning_lib;
 576
 577     } else {
 578         ($patron, $evt) = $apputils->fetch_user($map->target_usr);
 579         return $evt if $evt;
 580         $perm_org = $patron->home_ou;
 581     }
 582
 583
 584     ( $user_obj, $evt )  = $apputils->checkses($user_session);
 585     return $evt if $evt;
 586     $evt = $apputils->check_perms( $user_obj->id, $perm_org, $perm );
 587     return $evt if $evt;
 588
 589
 590     my $session = $apputils->start_db_session();
 591     $apputils->set_audit_info($session, $user_session, $user_obj->id, $user_obj->wsid);
 592     my $req = $session->request($method, $map);
 593     my $newid = $req->gather(1);
 594     warn "Updated new stat cat map with id $newid\n";
 595     $apputils->commit_db_session($session);
 596
 597     return $newid;
 598 }
 599
 600
 601
 602 __PACKAGE__->register_method(
 603     method  => "retrieve_maps",
 604     api_name    => "open-ils.circ.stat_cat.actor.user_map.retrieve");
 605
 606 __PACKAGE__->register_method(
 607     method  => "retrieve_maps",
 608     api_name    => "open-ils.circ.stat_cat.asset.copy_map.retrieve");
 609
 610 sub retrieve_maps {
 611     my( $self, $client, $user_session, $target ) = @_;
 612
 613
 614     my( $user_obj, $evt ) = $apputils->checkses($user_session);
 615     return $evt if $evt;
 616
 617     my  $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.search.owning_copy.atomic";
 618     if($self->api_name =~ /actor/ ) {
 619         if(!$target) { $target = $user_obj->id; }
 620         $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.search.target_usr.atomic";
 621     }
 622
 623     return $apputils->simple_scalar_request("open-ils.storage", $method, $target);
 624 }
 625
 626
 627
 628
 629 __PACKAGE__->register_method(
 630     method  => "delete_stats",
 631     api_name    => "open-ils.circ.stat_cat.actor.delete");
 632
 633 __PACKAGE__->register_method(
 634     method  => "delete_stats",
 635     api_name    => "open-ils.circ.stat_cat.asset.delete");
 636
 637 sub delete_stats {
 638     my( $self, $client, $user_session, $target ) = @_;
 639
 640     my $cat;
 641
 642     my $type = "actor";
 643     my $perm = 'DELETE_PATRON_STAT_CAT';
 644     if($self->api_name =~ /asset/) {
 645         $type = "asset";
 646         $perm = 'DELETE_COPY_STAT_CAT';
 647     }
 648
 649     my( $user_obj, $evt )  = $apputils->checkses($user_session);
 650     return $evt if $evt;
 651
 652     ( $cat, $evt ) = $apputils->fetch_stat_cat( $type, $target );
 653     return $evt if $evt;
 654
 655     $evt = $apputils->check_perms( $user_obj->id, $cat->owner, $perm );
 656     return $evt if $evt;
 657
 658     my $session = OpenSRF::AppSession->create("open-ils.storage");
 659     return _delete_stats($session, $target, $type);
 660 }
 661
 662 sub _delete_stats {
 663     my( $session, $stat, $type) = @_;
 664
 665     my  $method = "open-ils.storage.direct.asset.stat_cat.delete";
 666     if($type =~ /actor/ ) {
 667         $method = "open-ils.storage.direct.actor.stat_cat.delete";
 668     }
 669     return $session->request($method, $stat)->gather(1);
 670 }
 671
 672
 673
 674 __PACKAGE__->register_method(
 675     method  => "delete_entry",
 676     api_name    => "open-ils.circ.stat_cat.actor.entry.delete");
 677
 678 __PACKAGE__->register_method(
 679     method  => "delete_entry",
 680     api_name    => "open-ils.circ.stat_cat.asset.entry.delete");
 681
 682 sub delete_entry {
 683     my( $self, $client, $user_session, $target ) = @_;
 684
 685     my $type = "actor";
 686     my $perm = 'DELETE_PATRON_STAT_CAT_ENTRY';
 687     if($self->api_name =~ /asset/) {
 688         $type = "asset";
 689         $perm = 'DELETE_COPY_STAT_CAT_ENTRY';
 690     }
 691
 692     my $entry;
 693     my( $user_obj, $evt )  = $apputils->checkses($user_session);
 694     return $evt if $evt;
 695
 696     ( $entry, $evt ) = $apputils->fetch_stat_cat_entry( $type, $target );
 697     return $evt if $evt;
 698
 699     $evt = $apputils->check_perms( $user_obj->id, $entry->owner, $perm );
 700     return $evt if $evt;
 701
 702     my $session = OpenSRF::AppSession->create("open-ils.storage");
 703     return _delete_entry($session, $target, $type);
 704 }
 705
 706 sub _delete_entry {
 707     my( $session, $stat_entry, $type) = @_;
 708
 709     my  $method = "open-ils.storage.direct.asset.stat_cat_entry.delete";
 710     if($type =~ /actor/ ) {
 711         $method = "open-ils.storage.direct.actor.stat_cat_entry.delete";
 712     }
 713
 714     return $session->request($method, $stat_entry)->gather(1);
 715 }
 716
 717
 718 __PACKAGE__->register_method(
 719     method => "delete_entry_default",
 720     api_name => "open-ils.circ.stat_cat.actor.entry.default.delete");
 721
 722 sub delete_entry_default {
 723     my( $self, $client, $user_session, $target ) = @_;
 724
 725     my $type = "actor";
 726     my $perm = 'DELETE_PATRON_STAT_CAT_ENTRY_DEFAULT';
 727
 728     my $default_entry;
 729     my( $user_obj, $evt )  = $apputils->checkses($user_session);
 730     return $evt if $evt;
 731
 732     ( $default_entry, $evt ) = $apputils->fetch_stat_cat_entry_default( $type, $target );
 733     return $evt if $evt;
 734
 735     $evt = $apputils->check_perms( $user_obj->id, $default_entry->owner, $perm );
 736     return $evt if $evt;
 737
 738     my $session = OpenSRF::AppSession->create("open-ils.storage");
 739     return _delete_entry_default($session, $target, $type);
 740 }
 741
 742 sub _delete_entry_default {
 743     my( $session, $stat_entry, $type) = @_;
 744
 745     my $method = "open-ils.storage.direct.actor.stat_cat_entry_default.delete";
 746     if($type =~ /asset/ ) {
 747         $method = "open-ils.storage.direct.asset.stat_cat_entry_default.delete";
 748     }
 749
 750     return $session->request($method, $stat_entry)->gather(1);
 751 }
 752
 753 __PACKAGE__->register_method(
 754     method => 'fetch_stats_by_copy',
 755     api_name    => 'open-ils.circ.asset.stat_cat_entries.fleshed.retrieve_by_copy',
 756 );
 757
 758
 759 sub fetch_stats_by_copy {
 760     my( $self, $conn, $args ) = @_;
 761
 762     my @entries;
 763
 764     if( $$args{public} ) {
 765         my $maps = $U->cstorereq(
 766             'open-ils.cstore.direct.asset.stat_cat_entry_copy_map.search.atomic', { owning_copy => $$args{copyid} });
 767
 768
 769         warn "here\n";
 770         for my $map (@$maps) {
 771
 772             warn "map ".$map->id."\n";
 773             warn "map ".$map->stat_cat_entry."\n";
 774
 775             my $entry = $U->cstorereq(
 776                 'open-ils.cstore.direct.asset.stat_cat_entry.retrieve', $map->stat_cat_entry);
 777
 778             warn "Found entry ".$entry->id."\n";
 779
 780             my $cat = $U->cstorereq(
 781                 'open-ils.cstore.direct.asset.stat_cat.retrieve', $entry->stat_cat );
 782             $entry->stat_cat( $cat );
 783             push( @entries, $entry );
 784         }
 785     }
 786
 787     return \@entries;
 788 }
 789
 790 __PACKAGE__->register_method(
 791     method => 'retrieve_entry_default',
 792     api_name => "open-ils.circ.stat_cat.actor.entry_default.ancestor_default",
 793 );
 794
 795 sub retrieve_entry_default {
 796     my( $self, $client, $user_session, $orgid, $stat_cat ) = @_;
 797
 798     my $method = "open-ils.storage.actor.stat_cat_entry_default.ancestor.retrieve.atomic";
 799
 800     return $apputils->simple_scalar_request( "open-ils.storage", $method, $orgid, $stat_cat);
 801 }
 802
 803
 804
 805 1;