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