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