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

   1 package OpenILS::Application::Circ::StatCat;
   2 use base qw/OpenSRF::Application/;
   3 use strict; use warnings;
   4
   5 use OpenSRF::EX qw/:try/;
   6 use OpenILS::Application::AppUtils;
   7 my $apputils = "OpenILS::Application::AppUtils";
   8
   9
  10
  11 __PACKAGE__->register_method(
  12         method  => "retrieve_stat_cats",
  13         api_name        => "open-ils.circ.stat_cat.actor.retrieve.all");
  14
  15 __PACKAGE__->register_method(
  16         method  => "retrieve_stat_cats",
  17         api_name        => "open-ils.circ.stat_cat.asset.retrieve.all");
  18
  19 # retrieves all of the stat cats for a given org unit
  20 # if no orgid, user_session->home_ou is used
  21
  22 sub retrieve_stat_cats {
  23         my( $self, $client, $user_session, $orgid ) = @_;
  24
  25         my $user_obj = $apputils->check_user_session($user_session);
  26         if(!$orgid) { $orgid = $user_obj->home_ou; }
  27
  28         my $method = "open-ils.storage.ranged.fleshed.actor.stat_cat.all.atomic";
  29         if( $self->api_name =~ /asset/ ) {
  30                 $method = "open-ils.storage.ranged.fleshed.asset.stat_cat.all.atomic";
  31         }
  32
  33         return $apputils->simple_scalar_request(
  34                                 "open-ils.storage", $method, $orgid );
  35 }
  36
  37
  38
  39 __PACKAGE__->register_method(
  40         method  => "retrieve_ranged_intersect_stat_cats",
  41         api_name        => "open-ils.circ.stat_cat.asset.multirange.intersect.retrieve");
  42
  43 sub retrieve_ranged_intersect_stat_cats {
  44         my( $self, $client, $user_session, $orglist ) = @_;
  45
  46         my $user_obj = $apputils->check_user_session($user_session);
  47         if(!$orglist) { $orglist = [ $user_obj->home_ou ]; }
  48
  49         # uniquify, yay!
  50         my %hash = map { ($_ => 1) } @$orglist;
  51         $orglist = [ keys %hash ];
  52
  53         warn "range: @$orglist\n";
  54
  55         my      $method = "open-ils.storage.multiranged.intersect.fleshed.asset.stat_cat.all.atomic";
  56         return $apputils->simple_scalar_request(
  57                                 "open-ils.storage", $method, $orglist );
  58 }
  59
  60
  61 __PACKAGE__->register_method(
  62         method  => "retrieve_ranged_union_stat_cats",
  63         api_name        => "open-ils.circ.stat_cat.asset.multirange.union.retrieve");
  64
  65 sub retrieve_ranged_union_stat_cats {
  66         my( $self, $client, $user_session, $orglist ) = @_;
  67
  68         my $user_obj = $apputils->check_user_session($user_session);
  69         if(!$orglist) { $orglist = [ $user_obj->home_ou ]; }
  70
  71         # uniquify, yay!
  72         my %hash = map { ($_ => 1) } @$orglist;
  73         $orglist = [ keys %hash ];
  74
  75         warn "range: @$orglist\n";
  76
  77         my      $method = "open-ils.storage.multiranged.union.fleshed.asset.stat_cat.all.atomic";
  78         return $apputils->simple_scalar_request(
  79                                 "open-ils.storage", $method, $orglist );
  80 }
  81
  82
  83
  84
  85
  86 __PACKAGE__->register_method(
  87         method  => "stat_cat_create",
  88         api_name        => "open-ils.circ.stat_cat.asset.create");
  89
  90 __PACKAGE__->register_method(
  91         method  => "stat_cat_create",
  92         api_name        => "open-ils.circ.stat_cat.actor.create");
  93
  94 sub stat_cat_create {
  95         my( $self, $client, $user_session, $stat_cat ) = @_;
  96
  97         if(!$stat_cat) {
  98                 throw OpenSRF::EX::ERROR
  99                         ("stat_cat.*.create requires a stat_cat object");
 100         }
 101
 102         my $user_obj = $apputils->check_user_session($user_session);
 103         my $orgid = $user_obj->home_ou();
 104
 105         my $method = "open-ils.storage.direct.actor.stat_cat.create";
 106         my $entry_create = "open-ils.storage.direct.actor.stat_cat_entry.create";
 107
 108         if($self->api_name =~ /asset/) {
 109                 $method = "open-ils.storage.direct.asset.stat_cat.create";
 110                 $entry_create = "open-ils.storage.direct.asset.stat_cat_entry.create";
 111         }
 112
 113         my $session = $apputils->start_db_session();
 114         my $newid = _create_stat_cat($session, $stat_cat, $method);
 115
 116         for my $entry (@{$stat_cat->entries}) {
 117                 $entry->stat_cat($newid);
 118                 _create_stat_entry($session, $entry, $entry_create);
 119         }
 120
 121         $apputils->commit_db_session($session);
 122
 123         warn "Stat cat creation successful with id $newid\n";
 124
 125         if( $self->api_name =~ /asset/ ) {
 126                 return _flesh_asset_cat($newid, $orgid);
 127         } else {
 128                 return _flesh_user_cat($newid, $orgid);
 129         }
 130
 131 }
 132
 133
 134 sub _flesh_user_cat {
 135         my $id = shift;
 136         my $orgid = shift;
 137
 138         my $session = OpenSRF::AppSession->create("open-ils.storage");
 139         my $cat = $session->request(
 140                 "open-ils.storage.direct.actor.stat_cat.retrieve",
 141                 $id )->gather(1);
 142
 143         $cat->entries(
 144                 $session->request(
 145                         "open-ils.storage.ranged.actor.stat_cat_entry.search.stat_cat.atomic",
 146                         $orgid, $id )->gather(1) );
 147
 148         return $cat;
 149 }
 150
 151
 152 sub _flesh_asset_cat {
 153         my $id = shift;
 154         my $orgid = shift;
 155
 156         my $session = OpenSRF::AppSession->create("open-ils.storage");
 157         my $cat = $session->request(
 158                 "open-ils.storage.direct.asset.stat_cat.retrieve",
 159                 $id )->gather(1);
 160
 161         $cat->entries(
 162                 $session->request(
 163                         "open-ils.storage.ranged.asset.stat_cat_entry.search.stat_cat.atomic",
 164                         $orgid,  $id )->gather(1) );
 165
 166         return $cat;
 167
 168 }
 169
 170
 171 sub _create_stat_cat {
 172         my( $session, $stat_cat, $method) = @_;
 173         warn "Creating new stat cat with name " . $stat_cat->name . "\n";
 174         $stat_cat->clear_id();
 175         my $req = $session->request( $method, $stat_cat );
 176         my $id = $req->gather(1);
 177         if(!$id) {
 178                 throw OpenSRF::EX::ERROR
 179                 ("Error creating new statistical category"); }
 180
 181         warn "Stat cat create returned id $id\n";
 182         return $id;
 183 }
 184
 185
 186 sub _create_stat_entry {
 187         my( $session, $stat_entry, $method) = @_;
 188
 189         warn "Creating new stat entry with value " . $stat_entry->value . "\n";
 190         $stat_entry->clear_id();
 191
 192         my $req = $session->request($method, $stat_entry);
 193         my $id = $req->gather(1);
 194
 195         warn "Stat entry " . Dumper($stat_entry) . "\n";
 196
 197         if(!$id) {
 198                 throw OpenSRF::EX::ERROR
 199                 ("Error creating new stat cat entry"); }
 200
 201         warn "Stat cat entry create returned id $id\n";
 202         return $id;
 203 }
 204
 205
 206 __PACKAGE__->register_method(
 207         method  => "update_stat_entry",
 208         api_name        => "open-ils.circ.stat_cat.actor.entry.update");
 209
 210 __PACKAGE__->register_method(
 211         method  => "update_stat_entry",
 212         api_name        => "open-ils.circ.stat_cat.asset.entry.update");
 213
 214 sub update_stat_entry {
 215         my( $self, $client, $user_session, $entry ) = @_;
 216
 217         my $user_obj = $apputils->check_user_session($user_session);
 218
 219         my $method = "open-ils.storage.direct.actor.stat_cat_entry.update";
 220         if($self->api_name =~ /asset/) {
 221                 $method = "open-ils.storage.direct.asset.stat_cat_entry.update";
 222         }
 223
 224         my $session = $apputils->start_db_session();
 225         my $req = $session->request($method, $entry);
 226         my $status = $req->gather(1);
 227         $apputils->commit_db_session($session);
 228         warn "stat cat entry with value " . $entry->value . " updated with status $status\n";
 229         return 1;
 230 }
 231
 232
 233 __PACKAGE__->register_method(
 234         method  => "update_stat",
 235         api_name        => "open-ils.circ.stat_cat.actor.update");
 236
 237 __PACKAGE__->register_method(
 238         method  => "update_stat",
 239         api_name        => "open-ils.circ.stat_cat.asset.update");
 240
 241 sub update_stat {
 242         my( $self, $client, $user_session, $cat ) = @_;
 243
 244         my $user_obj = $apputils->check_user_session($user_session);
 245
 246         my $method = "open-ils.storage.direct.actor.stat_cat.update";
 247         if($self->api_name =~ /asset/) {
 248                 $method = "open-ils.storage.direct.asset.stat_cat.update";
 249         }
 250
 251         my $session = $apputils->start_db_session();
 252         my $req = $session->request($method, $cat);
 253         my $status = $req->gather(1);
 254         $apputils->commit_db_session($session);
 255         warn "stat cat with id " . $cat->id . " updated with status $status\n";
 256         return 1;
 257 }
 258
 259
 260 __PACKAGE__->register_method(
 261         method  => "create_stat_entry",
 262         api_name        => "open-ils.circ.stat_cat.actor.entry.create");
 263
 264 __PACKAGE__->register_method(
 265         method  => "create_stat_entry",
 266         api_name        => "open-ils.circ.stat_cat.asset.entry.create");
 267
 268 sub create_stat_entry {
 269         my( $self, $client, $user_session, $entry ) = @_;
 270
 271         my $user_obj = $apputils->check_user_session($user_session);
 272
 273         $entry->clear_id();
 274         use Data::Dumper;
 275         warn Dumper($entry);
 276
 277         my $method = "open-ils.storage.direct.actor.stat_cat_entry.create";
 278         if($self->api_name =~ /asset/) {
 279                 $method = "open-ils.storage.direct.asset.stat_cat_entry.create";
 280         }
 281
 282         my $session = $apputils->start_db_session();
 283         my $req = $session->request($method, $entry);
 284         my $status = $req->gather(1);
 285         $apputils->commit_db_session($session);
 286
 287         warn "stat cat entry with id " . $status . " updated with status $status\n";
 288         return $status;
 289 }
 290
 291
 292
 293 __PACKAGE__->register_method(
 294         method  => "create_stat_map",
 295         api_name        => "open-ils.circ.stat_cat.actor.user_map.create");
 296
 297 __PACKAGE__->register_method(
 298         method  => "create_stat_map",
 299         api_name        => "open-ils.circ.stat_cat.asset.copy_map.create");
 300
 301 sub create_stat_map {
 302         my( $self, $client, $user_session, $map ) = @_;
 303
 304         my $user_obj = $apputils->check_user_session($user_session);
 305
 306         warn "Creating stat_cat_map\n";
 307
 308         $map->clear_id();
 309
 310         my $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.create";
 311         my $ret = "open-ils.storage.direct.actor.stat_cat_entry_user_map.retrieve";
 312         if($self->api_name =~ /asset/) {
 313                 $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.create";
 314                 $ret = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.retrieve";
 315         }
 316
 317         my $session = $apputils->start_db_session();
 318         my $req = $session->request($method, $map);
 319         my $newid = $req->gather(1);
 320         warn "Created new stat cat map with id $newid\n";
 321         $apputils->commit_db_session($session);
 322
 323         return $apputils->simple_scalar_request( "open-ils.storage", $ret, $newid );
 324
 325 }
 326
 327
 328 __PACKAGE__->register_method(
 329         method  => "update_stat_map",
 330         api_name        => "open-ils.circ.stat_cat.actor.user_map.update");
 331
 332 __PACKAGE__->register_method(
 333         method  => "update_stat_map",
 334         api_name        => "open-ils.circ.stat_cat.asset.copy_map.update");
 335
 336 sub update_stat_map {
 337         my( $self, $client, $user_session, $map ) = @_;
 338
 339         my $user_obj = $apputils->check_user_session($user_session);
 340
 341         warn "Updating stat_cat_map\n";
 342
 343         my $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.update";
 344         if($self->api_name =~ /asset/) {
 345                 $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.update";
 346         }
 347
 348         my $session = $apputils->start_db_session();
 349         my $req = $session->request($method, $map);
 350         my $newid = $req->gather(1);
 351         warn "Updated new stat cat map with id $newid\n";
 352         $apputils->commit_db_session($session);
 353
 354         return $newid;
 355 }
 356
 357
 358
 359 __PACKAGE__->register_method(
 360         method  => "retrieve_maps",
 361         api_name        => "open-ils.circ.stat_cat.actor.user_map.retrieve");
 362
 363 __PACKAGE__->register_method(
 364         method  => "retrieve_maps",
 365         api_name        => "open-ils.circ.stat_cat.asset.copy_map.retrieve");
 366
 367 sub retrieve_maps {
 368         my( $self, $client, $user_session, $target ) = @_;
 369
 370         my $user_obj = $apputils->check_user_session($user_session);
 371
 372         my      $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.search.owning_copy";
 373         if($self->api_name =~ /actor/ ) {
 374                 if(!$target) { $target = $user_obj->id; }
 375                 $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.search.target_usr";
 376         }
 377
 378         return $apputils->simple_scalar_request("open-ils.storage", $method, $target);
 379 }
 380
 381
 382
 383
 384 __PACKAGE__->register_method(
 385         method  => "delete_stats",
 386         api_name        => "open-ils.circ.stat_cat.actor.delete");
 387
 388 __PACKAGE__->register_method(
 389         method  => "delete_stats",
 390         api_name        => "open-ils.circ.stat_cat.asset.delete");
 391
 392 sub delete_stats {
 393         my( $self, $client, $user_session, $target ) = @_;
 394         my $user_obj = $apputils->check_user_session($user_session);
 395         my $session = OpenSRF::AppSession->create("open-ils.storage");
 396         my $type = "actor";
 397         if($self->api_name =~ /asset/) { $type = "asset"; }
 398         return _delete_stats($session, $target, $type);
 399 }
 400
 401 sub _delete_stats {
 402         my( $session, $stat, $type) = @_;
 403
 404         my      $method = "open-ils.storage.direct.asset.stat_cat.delete";
 405         if($type =~ /actor/ ) {
 406                 $method = "open-ils.storage.direct.actor.stat_cat.delete";
 407         }
 408         return $session->request($method, $stat)->gather(1);
 409 }
 410
 411
 412
 413 __PACKAGE__->register_method(
 414         method  => "delete_entry",
 415         api_name        => "open-ils.circ.stat_cat.actor.entry.delete");
 416
 417 __PACKAGE__->register_method(
 418         method  => "delete_entry",
 419         api_name        => "open-ils.circ.stat_cat.asset.entry.delete");
 420
 421 sub delete_entry {
 422         my( $self, $client, $user_session, $target ) = @_;
 423         my $user_obj = $apputils->check_user_session($user_session);
 424         my $session = OpenSRF::AppSession->create("open-ils.storage");
 425         my $type = "actor";
 426         if($self->api_name =~ /asset/) { $type = "asset"; }
 427         return _delete_entry($session, $target, $type);
 428 }
 429
 430 sub _delete_entry {
 431         my( $session, $stat_entry, $type) = @_;
 432
 433         my      $method = "open-ils.storage.direct.asset.stat_cat_entry.delete";
 434         if($type =~ /actor/ ) {
 435                 $method = "open-ils.storage.direct.actor.stat_cat_entry.delete";
 436         }
 437
 438         return $session->request($method, $stat_entry)->gather(1);
 439 }
 440
 441
 442
 443 1;