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         my $newid = _create_stat_cat($session, $stat_cat, $method);
 181
 182         if( ref($stat_cat->entries) ) {
 183                 for my $entry (@{$stat_cat->entries}) {
 184                         $entry->stat_cat($newid);
 185                         _create_stat_entry($session, $entry, $entry_create);
 186                 }
 187         }
 188
 189         $apputils->commit_db_session($session);
 190
 191         $logger->debug("Stat cat creation successful with id $newid");
 192
 193         my $orgid = $user_obj->home_ou;
 194         if( $self->api_name =~ /asset/ ) {
 195                 return _flesh_asset_cat($newid, $orgid);
 196         } else {
 197                 return _flesh_user_cat($newid, $orgid);
 198         }
 199 }
 200
 201
 202 sub _flesh_user_cat {
 203         my $id = shift;
 204         my $orgid = shift;
 205
 206         my $session = OpenSRF::AppSession->create("open-ils.storage");
 207         my $cat = $session->request(
 208                 "open-ils.storage.direct.actor.stat_cat.retrieve",
 209                 $id )->gather(1);
 210
 211         $cat->entries(
 212                 $session->request(
 213                         "open-ils.storage.ranged.actor.stat_cat_entry.search.stat_cat.atomic",
 214                         $orgid, $id )->gather(1) );
 215
 216         return $cat;
 217 }
 218
 219
 220 sub _flesh_asset_cat {
 221         my $id = shift;
 222         my $orgid = shift;
 223
 224         my $session = OpenSRF::AppSession->create("open-ils.storage");
 225         my $cat = $session->request(
 226                 "open-ils.storage.direct.asset.stat_cat.retrieve",
 227                 $id )->gather(1);
 228
 229         $cat->entries(
 230                 $session->request(
 231                         "open-ils.storage.ranged.asset.stat_cat_entry.search.stat_cat.atomic",
 232                         $orgid,  $id )->gather(1) );
 233
 234         return $cat;
 235
 236 }
 237
 238
 239 sub _create_stat_cat {
 240         my( $session, $stat_cat, $method) = @_;
 241         warn "Creating new stat cat with name " . $stat_cat->name . "\n";
 242         $stat_cat->clear_id();
 243         my $req = $session->request( $method, $stat_cat );
 244         my $id = $req->gather(1);
 245         if(!$id) {
 246                 throw OpenSRF::EX::ERROR
 247                 ("Error creating new statistical category"); }
 248
 249         warn "Stat cat create returned id $id\n";
 250         return $id;
 251 }
 252
 253
 254 sub _create_stat_entry {
 255         my( $session, $stat_entry, $method) = @_;
 256
 257         warn "Creating new stat entry with value " . $stat_entry->value . "\n";
 258         $stat_entry->clear_id();
 259
 260         my $req = $session->request($method, $stat_entry);
 261         my $id = $req->gather(1);
 262
 263         warn "Stat entry " . Dumper($stat_entry) . "\n";
 264
 265         if(!$id) {
 266                 throw OpenSRF::EX::ERROR
 267                 ("Error creating new stat cat entry"); }
 268
 269         warn "Stat cat entry create returned id $id\n";
 270         return $id;
 271 }
 272
 273
 274 __PACKAGE__->register_method(
 275         method  => "update_stat_entry",
 276         api_name        => "open-ils.circ.stat_cat.actor.entry.update");
 277
 278 __PACKAGE__->register_method(
 279         method  => "update_stat_entry",
 280         api_name        => "open-ils.circ.stat_cat.asset.entry.update");
 281
 282 sub update_stat_entry {
 283         my( $self, $client, $user_session, $entry ) = @_;
 284
 285
 286         my $method = "open-ils.storage.direct.actor.stat_cat_entry.update";
 287         my $perm = 'UPDATE_PATRON_STAT_CAT_ENTRY';
 288         if($self->api_name =~ /asset/) {
 289                 $method = "open-ils.storage.direct.asset.stat_cat_entry.update";
 290                 $perm = 'UPDATE_COPY_STAT_CAT_ENTRY';
 291         }
 292
 293         my( $user_obj, $evt )  = $apputils->checkses($user_session);
 294         return $evt if $evt;
 295         $evt = $apputils->check_perms( $user_obj->id, $entry->owner, $perm );
 296         return $evt if $evt;
 297
 298         my $session = $apputils->start_db_session();
 299         my $req = $session->request($method, $entry);
 300         my $status = $req->gather(1);
 301         $apputils->commit_db_session($session);
 302         warn "stat cat entry with value " . $entry->value . " updated with status $status\n";
 303         return 1;
 304 }
 305
 306
 307 __PACKAGE__->register_method(
 308         method  => "update_stat",
 309         api_name        => "open-ils.circ.stat_cat.actor.update");
 310
 311 __PACKAGE__->register_method(
 312         method  => "update_stat",
 313         api_name        => "open-ils.circ.stat_cat.asset.update");
 314
 315 sub update_stat {
 316         my( $self, $client, $user_session, $cat ) = @_;
 317
 318         my $method = "open-ils.storage.direct.actor.stat_cat.update";
 319         my $perm = 'UPDATE_PATRON_STAT_CAT';
 320         if($self->api_name =~ /asset/) {
 321                 $method = "open-ils.storage.direct.asset.stat_cat.update";
 322                 $perm = 'UPDATE_COPY_STAT_CAT';
 323         }
 324
 325         my( $user_obj, $evt )  = $apputils->checkses($user_session);
 326         return $evt if $evt;
 327         $evt = $apputils->check_perms( $user_obj->id, $cat->owner, $perm );
 328         return $evt if $evt;
 329
 330         my $session = $apputils->start_db_session();
 331         my $req = $session->request($method, $cat);
 332         my $status = $req->gather(1);
 333         $apputils->commit_db_session($session);
 334         warn "stat cat with id " . $cat->id . " updated with status $status\n";
 335         return 1;
 336 }
 337
 338
 339 __PACKAGE__->register_method(
 340         method  => "create_stat_entry",
 341         api_name        => "open-ils.circ.stat_cat.actor.entry.create");
 342
 343 __PACKAGE__->register_method(
 344         method  => "create_stat_entry",
 345         api_name        => "open-ils.circ.stat_cat.asset.entry.create");
 346
 347 sub create_stat_entry {
 348         my( $self, $client, $user_session, $entry ) = @_;
 349
 350         my $method = "open-ils.storage.direct.actor.stat_cat_entry.create";
 351         my $perm = 'CREATE_PATRON_STAT_CAT_ENTRY';
 352         if($self->api_name =~ /asset/) {
 353                 $method = "open-ils.storage.direct.asset.stat_cat_entry.create";
 354                 $perm = 'CREATE_COPY_STAT_CAT_ENTRY';
 355         }
 356
 357         my( $user_obj, $evt )  = $apputils->checkses($user_session);
 358         return $evt if $evt;
 359         $evt = $apputils->check_perms( $user_obj->id, $entry->owner, $perm );
 360         return $evt if $evt;
 361
 362         $entry->clear_id();
 363         my $session = $apputils->start_db_session();
 364         my $req = $session->request($method, $entry);
 365         my $status = $req->gather(1);
 366         $apputils->commit_db_session($session);
 367
 368         $logger->info("created stat cat entry $status");
 369         return $status;
 370 }
 371
 372
 373
 374 __PACKAGE__->register_method(
 375         method  => "create_stat_map",
 376         api_name        => "open-ils.circ.stat_cat.actor.user_map.create");
 377
 378 __PACKAGE__->register_method(
 379         method  => "create_stat_map",
 380         api_name        => "open-ils.circ.stat_cat.asset.copy_map.create");
 381
 382 sub create_stat_map {
 383         my( $self, $client, $user_session, $map ) = @_;
 384
 385
 386         my ( $evt, $copy, $volume, $patron, $user_obj );
 387
 388         my $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.create";
 389         my $ret = "open-ils.storage.direct.actor.stat_cat_entry_user_map.retrieve";
 390         my $perm = 'CREATE_PATRON_STAT_CAT_ENTRY_MAP';
 391         my $perm_org;
 392
 393         if($self->api_name =~ /asset/) {
 394                 $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.create";
 395                 $ret = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.retrieve";
 396                 $perm = 'CREATE_COPY_STAT_CAT_ENTRY_MAP';
 397                 ( $copy, $evt ) = $apputils->fetch_copy($map->owning_copy);
 398                 return $evt if $evt;
 399                 ( $volume, $evt ) = $apputils->fetch_callnumber($copy->call_number);
 400                 return $evt if $evt;
 401                 $perm_org = $volume->owning_lib;
 402
 403         } else {
 404                 ($patron, $evt) = $apputils->fetch_user($map->target_usr);
 405                 return $evt if $evt;
 406                 $perm_org = $patron->home_ou;
 407         }
 408
 409         ( $user_obj, $evt )  = $apputils->checkses($user_session);
 410         return $evt if $evt;
 411         $evt = $apputils->check_perms( $user_obj->id, $perm_org, $perm );
 412         return $evt if $evt;
 413
 414         $logger->debug( $user_obj->id . " creating new stat cat map" );
 415
 416         $map->clear_id();
 417
 418         my $session = $apputils->start_db_session();
 419         my $req = $session->request($method, $map);
 420         my $newid = $req->gather(1);
 421         warn "Created new stat cat map with id $newid\n";
 422         $apputils->commit_db_session($session);
 423
 424         return $apputils->simple_scalar_request( "open-ils.storage", $ret, $newid );
 425
 426 }
 427
 428
 429 __PACKAGE__->register_method(
 430         method  => "update_stat_map",
 431         api_name        => "open-ils.circ.stat_cat.actor.user_map.update");
 432
 433 __PACKAGE__->register_method(
 434         method  => "update_stat_map",
 435         api_name        => "open-ils.circ.stat_cat.asset.copy_map.update");
 436
 437 sub update_stat_map {
 438         my( $self, $client, $user_session, $map ) = @_;
 439
 440         my ( $evt, $copy, $volume, $patron, $user_obj );
 441
 442         my $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.update";
 443         my $perm = 'UPDATE_PATRON_STAT_ENTRY_MAP';
 444         my $perm_org;
 445
 446         if($self->api_name =~ /asset/) {
 447                 $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.update";
 448                 $perm = 'UPDATE_COPY_STAT_ENTRY_MAP';
 449                 ( $copy, $evt ) = $apputils->fetch_copy($map->owning_copy);
 450                 return $evt if $evt;
 451                 ( $volume, $evt ) = $apputils->fetch_callnumber($copy->call_number);
 452                 return $evt if $evt;
 453                 $perm_org = $volume->owning_lib;
 454
 455         } else {
 456                 ($patron, $evt) = $apputils->fetch_user($map->target_usr);
 457                 return $evt if $evt;
 458                 $perm_org = $patron->home_ou;
 459         }
 460
 461
 462         ( $user_obj, $evt )  = $apputils->checkses($user_session);
 463         return $evt if $evt;
 464         $evt = $apputils->check_perms( $user_obj->id, $perm_org, $perm );
 465         return $evt if $evt;
 466
 467
 468         my $session = $apputils->start_db_session();
 469         my $req = $session->request($method, $map);
 470         my $newid = $req->gather(1);
 471         warn "Updated new stat cat map with id $newid\n";
 472         $apputils->commit_db_session($session);
 473
 474         return $newid;
 475 }
 476
 477
 478
 479 __PACKAGE__->register_method(
 480         method  => "retrieve_maps",
 481         api_name        => "open-ils.circ.stat_cat.actor.user_map.retrieve");
 482
 483 __PACKAGE__->register_method(
 484         method  => "retrieve_maps",
 485         api_name        => "open-ils.circ.stat_cat.asset.copy_map.retrieve");
 486
 487 sub retrieve_maps {
 488         my( $self, $client, $user_session, $target ) = @_;
 489
 490
 491         my( $user_obj, $evt ) = $apputils->checkses($user_session);
 492         return $evt if $evt;
 493
 494         my      $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.search.owning_copy.atomic";
 495         if($self->api_name =~ /actor/ ) {
 496                 if(!$target) { $target = $user_obj->id; }
 497                 $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.search.target_usr.atomic";
 498         }
 499
 500         return $apputils->simple_scalar_request("open-ils.storage", $method, $target);
 501 }
 502
 503
 504
 505
 506 __PACKAGE__->register_method(
 507         method  => "delete_stats",
 508         api_name        => "open-ils.circ.stat_cat.actor.delete");
 509
 510 __PACKAGE__->register_method(
 511         method  => "delete_stats",
 512         api_name        => "open-ils.circ.stat_cat.asset.delete");
 513
 514 sub delete_stats {
 515         my( $self, $client, $user_session, $target ) = @_;
 516
 517         my $cat;
 518
 519         my $type = "actor";
 520         my $perm = 'DELETE_PATRON_STAT_CAT';
 521         if($self->api_name =~ /asset/) {
 522                 $type = "asset";
 523                 $perm = 'DELETE_COPY_STAT_CAT';
 524         }
 525
 526         my( $user_obj, $evt )  = $apputils->checkses($user_session);
 527         return $evt if $evt;
 528
 529         ( $cat, $evt ) = $apputils->fetch_stat_cat( $type, $target );
 530         return $evt if $evt;
 531
 532         $evt = $apputils->check_perms( $user_obj->id, $cat->owner, $perm );
 533         return $evt if $evt;
 534
 535         my $session = OpenSRF::AppSession->create("open-ils.storage");
 536         return _delete_stats($session, $target, $type);
 537 }
 538
 539 sub _delete_stats {
 540         my( $session, $stat, $type) = @_;
 541
 542         my      $method = "open-ils.storage.direct.asset.stat_cat.delete";
 543         if($type =~ /actor/ ) {
 544                 $method = "open-ils.storage.direct.actor.stat_cat.delete";
 545         }
 546         return $session->request($method, $stat)->gather(1);
 547 }
 548
 549
 550
 551 __PACKAGE__->register_method(
 552         method  => "delete_entry",
 553         api_name        => "open-ils.circ.stat_cat.actor.entry.delete");
 554
 555 __PACKAGE__->register_method(
 556         method  => "delete_entry",
 557         api_name        => "open-ils.circ.stat_cat.asset.entry.delete");
 558
 559 sub delete_entry {
 560         my( $self, $client, $user_session, $target ) = @_;
 561
 562         my $type = "actor";
 563         my $perm = 'DELETE_PATRON_STAT_CAT_ENTRY';
 564         if($self->api_name =~ /asset/) {
 565                 $type = "asset";
 566                 $perm = 'DELETE_COPY_STAT_CAT_ENTRY';
 567         }
 568
 569         my $entry;
 570         my( $user_obj, $evt )  = $apputils->checkses($user_session);
 571         return $evt if $evt;
 572
 573         ( $entry, $evt ) = $apputils->fetch_stat_cat_entry( $type, $target );
 574         return $evt if $evt;
 575
 576         $evt = $apputils->check_perms( $user_obj->id, $entry->owner, $perm );
 577         return $evt if $evt;
 578
 579         my $session = OpenSRF::AppSession->create("open-ils.storage");
 580         return _delete_entry($session, $target, $type);
 581 }
 582
 583 sub _delete_entry {
 584         my( $session, $stat_entry, $type) = @_;
 585
 586         my      $method = "open-ils.storage.direct.asset.stat_cat_entry.delete";
 587         if($type =~ /actor/ ) {
 588                 $method = "open-ils.storage.direct.actor.stat_cat_entry.delete";
 589         }
 590
 591         return $session->request($method, $stat_entry)->gather(1);
 592 }
 593
 594
 595 __PACKAGE__->register_method(
 596         method => 'fetch_stats_by_copy',
 597         api_name        => 'open-ils.circ.asset.stat_cat_entries.fleshed.retrieve_by_copy',
 598 );
 599
 600
 601 sub fetch_stats_by_copy {
 602         my( $self, $conn, $args ) = @_;
 603
 604         my @entries;
 605
 606         if( $$args{public} ) {
 607                 my $maps = $U->cstorereq(
 608                         'open-ils.cstore.direct.asset.stat_cat_entry_copy_map.search.atomic', { owning_copy => $$args{copyid} });
 609
 610
 611                 warn "here\n";
 612                 for my $map (@$maps) {
 613
 614                         warn "map ".$map->id."\n";
 615                         warn "map ".$map->stat_cat_entry."\n";
 616
 617                         my $entry = $U->cstorereq(
 618                                 'open-ils.cstore.direct.asset.stat_cat_entry.retrieve', $map->stat_cat_entry);
 619
 620                         warn "Found entry ".$entry->id."\n";
 621
 622                         my $cat = $U->cstorereq(
 623                                 'open-ils.cstore.direct.asset.stat_cat.retrieve', $entry->stat_cat );
 624                         $entry->stat_cat( $cat );
 625                         push( @entries, $entry );
 626                 }
 627         }
 628
 629         return \@entries;
 630 }
 631
 632
 633
 634 1;