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_stat_cats",
  41         api_name        => "open-ils.circ.stat_cat.asset.multirange.retrieve");
  42
  43 sub retrieve_ranged_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.fleshed.asset.stat_cat.all.atomic";
  56         return $apputils->simple_scalar_request(
  57                                 "open-ils.storage", $method, $orglist );
  58 }
  59
  60
  61
  62
  63 __PACKAGE__->register_method(
  64         method  => "stat_cat_create",
  65         api_name        => "open-ils.circ.stat_cat.asset.create");
  66
  67 __PACKAGE__->register_method(
  68         method  => "stat_cat_create",
  69         api_name        => "open-ils.circ.stat_cat.actor.create");
  70
  71 sub stat_cat_create {
  72         my( $self, $client, $user_session, $stat_cat ) = @_;
  73
  74         if(!$stat_cat) {
  75                 throw OpenSRF::EX::ERROR
  76                         ("stat_cat.*.create requires a stat_cat object");
  77         }
  78
  79         my $user_obj = $apputils->check_user_session($user_session);
  80         my $orgid = $user_obj->home_ou();
  81
  82         my $method = "open-ils.storage.direct.actor.stat_cat.create";
  83         my $entry_create = "open-ils.storage.direct.actor.stat_cat_entry.create";
  84
  85         if($self->api_name =~ /asset/) {
  86                 $method = "open-ils.storage.direct.asset.stat_cat.create";
  87                 $entry_create = "open-ils.storage.direct.asset.stat_cat_entry.create";
  88         }
  89
  90         my $session = $apputils->start_db_session();
  91         my $newid = _create_stat_cat($session, $stat_cat, $method);
  92
  93         for my $entry (@{$stat_cat->entries}) {
  94                 $entry->stat_cat($newid);
  95                 _create_stat_entry($session, $entry, $entry_create);
  96         }
  97
  98         $apputils->commit_db_session($session);
  99
 100         warn "Stat cat creation successful with id $newid\n";
 101
 102         if( $self->api_name =~ /asset/ ) {
 103                 return _flesh_asset_cat($newid, $orgid);
 104         } else {
 105                 return _flesh_user_cat($newid, $orgid);
 106         }
 107
 108 }
 109
 110
 111 sub _flesh_user_cat {
 112         my $id = shift;
 113         my $orgid = shift;
 114
 115         my $session = OpenSRF::AppSession->create("open-ils.storage");
 116         my $cat = $session->request(
 117                 "open-ils.storage.direct.actor.stat_cat.retrieve",
 118                 $id )->gather(1);
 119
 120         $cat->entries(
 121                 $session->request(
 122                         "open-ils.storage.ranged.actor.stat_cat_entry.search.stat_cat.atomic",
 123                         $orgid, $id )->gather(1) );
 124
 125         return $cat;
 126 }
 127
 128
 129 sub _flesh_asset_cat {
 130         my $id = shift;
 131         my $orgid = shift;
 132
 133         my $session = OpenSRF::AppSession->create("open-ils.storage");
 134         my $cat = $session->request(
 135                 "open-ils.storage.direct.asset.stat_cat.retrieve",
 136                 $id )->gather(1);
 137
 138         $cat->entries(
 139                 $session->request(
 140                         "open-ils.storage.ranged.asset.stat_cat_entry.search.stat_cat.atomic",
 141                         $orgid,  $id )->gather(1) );
 142
 143         return $cat;
 144
 145 }
 146
 147
 148 sub _create_stat_cat {
 149         my( $session, $stat_cat, $method) = @_;
 150         warn "Creating new stat cat with name " . $stat_cat->name . "\n";
 151         $stat_cat->clear_id();
 152         my $req = $session->request( $method, $stat_cat );
 153         my $id = $req->gather(1);
 154         if(!$id) {
 155                 throw OpenSRF::EX::ERROR
 156                 ("Error creating new statistical category"); }
 157
 158         warn "Stat cat create returned id $id\n";
 159         return $id;
 160 }
 161
 162
 163 sub _create_stat_entry {
 164         my( $session, $stat_entry, $method) = @_;
 165         warn "Creating new stat entry with value " . $stat_entry->value . "\n";
 166         $stat_entry->clear_id();
 167         my $req = $session->request($method, $stat_entry);
 168         my $id = $req->gather(1);
 169         if(!$id) {
 170                 throw OpenSRF::EX::ERROR
 171                 ("Error creating new stat cat entry"); }
 172
 173         warn "Stat cat entry create returned id $id\n";
 174         return $id;
 175 }
 176
 177
 178 __PACKAGE__->register_method(
 179         method  => "update_stat_entry",
 180         api_name        => "open-ils.circ.stat_cat.actor.entry.update");
 181
 182 __PACKAGE__->register_method(
 183         method  => "update_stat_entry",
 184         api_name        => "open-ils.circ.stat_cat.asset.entry.update");
 185
 186 sub update_stat_entry {
 187         my( $self, $client, $user_session, $entry ) = @_;
 188
 189         my $user_obj = $apputils->check_user_session($user_session);
 190
 191         my $method = "open-ils.storage.direct.actor.stat_cat_entry.update";
 192         if($self->api_name =~ /asset/) {
 193                 $method = "open-ils.storage.direct.asset.stat_cat_entry.update";
 194         }
 195
 196         my $session = $apputils->start_db_session();
 197         my $req = $session->request($method, $entry);
 198         my $status = $req->gather(1);
 199         $apputils->commit_db_session($session);
 200         warn "stat cat entry with value " . $entry->value . " updated with status $status\n";
 201         return 1;
 202 }
 203
 204
 205
 206 __PACKAGE__->register_method(
 207         method  => "create_stat_map",
 208         api_name        => "open-ils.circ.stat_cat.actor.user_map.create");
 209
 210 __PACKAGE__->register_method(
 211         method  => "create_stat_map",
 212         api_name        => "open-ils.circ.stat_cat.asset.copy_map.create");
 213
 214 sub create_stat_map {
 215         my( $self, $client, $user_session, $map ) = @_;
 216
 217         my $user_obj = $apputils->check_user_session($user_session);
 218
 219         warn "Creating stat_cat_map\n";
 220
 221         $map->clear_id();
 222
 223         my $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.create";
 224         my $ret = "open-ils.storage.direct.actor.stat_cat_entry_user_map.retrieve";
 225         if($self->api_name =~ /asset/) {
 226                 $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.create";
 227                 $ret = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.retrieve";
 228         }
 229
 230         my $session = $apputils->start_db_session();
 231         my $req = $session->request($method, $map);
 232         my $newid = $req->gather(1);
 233         warn "Created new stat cat map with id $newid\n";
 234         $apputils->commit_db_session($session);
 235
 236         return $apputils->simple_scalar_request( "open-ils.storage", $ret, $newid );
 237
 238 }
 239
 240
 241
 242 __PACKAGE__->register_method(
 243         method  => "retrieve_maps",
 244         api_name        => "open-ils.circ.stat_cat.actor.user_map.retrieve");
 245
 246 __PACKAGE__->register_method(
 247         method  => "retrieve_maps",
 248         api_name        => "open-ils.circ.stat_cat.asset.copy_map.retrieve");
 249
 250 sub retrieve_maps {
 251         my( $self, $client, $user_session, $target ) = @_;
 252
 253         my $user_obj = $apputils->check_user_session($user_session);
 254
 255         my      $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.search.owning_copy";
 256         if($self->api_name =~ /actor/ ) {
 257                 if(!$target) { $target = $user_obj->id; }
 258                 $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.search.target_usr";
 259         }
 260
 261         return $apputils->simple_scalar_request("open-ils.storage", $method, $target);
 262 }
 263
 264
 265
 266
 267
 268
 269
 270
 271
 272
 273
 274 1;