Open-ILS/src/perlmods/OpenILS/Application/AppUtils.pm

   1 package OpenILS::Application::AppUtils;
   2 use strict; use warnings;
   3 use base qw/OpenSRF::Application/;
   4 use OpenSRF::Utils::Cache;
   5
   6
   7 my $cache_client = "OpenSRF::Utils::Cache";
   8
   9 # ---------------------------------------------------------------------------
  10 # Pile of utilty methods used accross applications.
  11 # ---------------------------------------------------------------------------
  12
  13
  14 # ---------------------------------------------------------------------------
  15 # on sucess, returns the created session, on failure throws ERROR exception
  16 # ---------------------------------------------------------------------------
  17 sub start_db_session {
  18
  19         my $self = shift;
  20         my $session = OpenSRF::AppSession->connect( "open-ils.storage" );
  21         my $trans_req = $session->request( "open-ils.storage.transaction.begin" );
  22
  23         my $trans_resp = $trans_req->recv();
  24         if(ref($trans_resp) and UNIVERSAL::isa($trans_resp,"Error")) { throw $trans_resp; }
  25         if( ! $trans_resp->content() ) {
  26                 throw OpenSRF::ERROR
  27                         ("Unable to Begin Transaction with database" );
  28         }
  29         $trans_req->finish();
  30         return $session;
  31 }
  32
  33 # ---------------------------------------------------------------------------
  34 # commits and destroys the session
  35 # ---------------------------------------------------------------------------
  36 sub commit_db_session {
  37         my( $self, $session ) = @_;
  38
  39         my $req = $session->request( "open-ils.storage.transaction.commit" );
  40         my $resp = $req->recv();
  41
  42         if(!$resp) {
  43                 throw OpenSRF::EX::ERROR ("Unable to commit db session");
  44         }
  45
  46         if(UNIVERSAL::isa($resp,"Error")) {
  47                 throw $resp ($resp->stringify);
  48         }
  49
  50         if(!$resp->content) {
  51                 throw OpenSRF::EX::ERROR ("Unable to commit db session");
  52         }
  53
  54         $session->finish();
  55         $session->disconnect();
  56         $session->kill_me();
  57 }
  58
  59 sub rollback_db_session {
  60         my( $self, $session ) = @_;
  61
  62         my $req = $session->request("open-ils.storage.transaction.rollback");
  63         my $resp = $req->recv();
  64         if(UNIVERSAL::isa($resp,"Error")) { throw $resp;  }
  65
  66         $session->finish();
  67         $session->disconnect();
  68         $session->kill_me();
  69 }
  70
  71 # ---------------------------------------------------------------------------
  72 # Checks to see if a user is logged in.  Returns the user record on success,
  73 # throws an exception on error.
  74 # ---------------------------------------------------------------------------
  75 sub check_user_session {
  76
  77         my( $self, $user_session ) = @_;
  78
  79         my $session = OpenSRF::AppSession->create( "open-ils.auth" );
  80         my $request = $session->request("open-ils.auth.session.retrieve", $user_session );
  81         my $response = $request->recv();
  82
  83         if(!$response) {
  84                 throw OpenSRF::EX::ERROR ("Session [$user_session] cannot be authenticated" );
  85         }
  86
  87         if($response->isa("OpenSRF::EX")) {
  88                 throw $response ($response->stringify);
  89         }
  90
  91         my $user = $response->content;
  92         if(!$user) {
  93                 throw OpenSRF::EX::ERROR ("Session [$user_session] cannot be authenticated" );
  94         }
  95
  96         $session->disconnect();
  97         $session->kill_me();
  98
  99         return $user;
 100
 101
 102 }
 103
 104 # generic simple request returning a scalar value
 105 sub simple_scalar_request {
 106         my($self, $service, $method, @params) = @_;
 107
 108         my $session = OpenSRF::AppSession->create( $service );
 109         my $request = $session->request( $method, @params );
 110         my $response = $request->recv(30);
 111
 112         $request->wait_complete;
 113
 114         if(!$request->complete) {
 115                 throw $response ("Call to $service for method $method with params @params" .
 116                                 "\n did not complete successfully");
 117         }
 118
 119         if(!$response) {
 120                 warn "No response from $service for method $method with params @params";
 121         }
 122
 123         if(UNIVERSAL::isa($response,"Error")) {
 124                 throw $response ("Call to $service for method $method with params @params" .
 125                                 "\n failed with exception: " . $response->stringify );
 126         }
 127
 128
 129         $request->finish();
 130         $session->finish();
 131         $session->disconnect();
 132
 133         my $value;
 134
 135         if($response) { $value = $response->content; }
 136         else { $value = undef; }
 137
 138         return $value;
 139 }
 140
 141
 142
 143
 144
 145 my $tree                                                = undef;
 146 my $orglist                                     = undef;
 147 my $org_typelist                        = undef;
 148 my $org_typelist_hash   = {};
 149
 150 sub get_org_tree {
 151
 152         my $self = shift;
 153         if($tree) { return $tree; }
 154
 155         # see if it's in the cache
 156         $tree = $cache_client->new()->get_cache('_orgtree');
 157         if($tree) { return $tree; }
 158
 159         if(!$orglist) {
 160                 warn "Retrieving Org Tree\n";
 161                 $orglist = $self->simple_scalar_request(
 162                         "open-ils.storage",
 163                         "open-ils.storage.direct.actor.org_unit.retrieve.all.atomic" );
 164         }
 165
 166         if( ! $org_typelist ) {
 167                 warn "Retrieving org types\n";
 168                 $org_typelist = $self->simple_scalar_request(
 169                         "open-ils.storage",
 170                         "open-ils.storage.direct.actor.org_unit_type.retrieve.all.atomic" );
 171                 $self->build_org_type($org_typelist);
 172         }
 173
 174         $tree = $self->build_org_tree($orglist,1);
 175         $cache_client->new()->put_cache('_orgtree', $tree);
 176         return $tree;
 177
 178 }
 179
 180 my $slimtree = undef;
 181 sub get_slim_org_tree {
 182
 183         my $self = shift;
 184         if($slimtree) { return $slimtree; }
 185
 186         # see if it's in the cache
 187         $slimtree = $cache_client->new()->get_cache('slimorgtree');
 188         if($slimtree) { return $slimtree; }
 189
 190         if(!$orglist) {
 191                 warn "Retrieving Org Tree\n";
 192                 $orglist = $self->simple_scalar_request(
 193                         "open-ils.storage",
 194                         "open-ils.storage.direct.actor.org_unit.retrieve.all.atomic" );
 195         }
 196
 197         $slimtree = $self->build_org_tree($orglist);
 198         $cache_client->new->put_cache('slimorgtree', $slimtree);
 199         return $slimtree;
 200
 201 }
 202
 203
 204 sub build_org_type {
 205         my($self, $org_typelist)  = @_;
 206         for my $type (@$org_typelist) {
 207                 $org_typelist_hash->{$type->id()} = $type;
 208         }
 209 }
 210
 211
 212
 213 sub build_org_tree {
 214
 215         my( $self, $orglist, $add_types ) = @_;
 216
 217
 218
 219         return $orglist unless (
 220                         ref($orglist) and @$orglist > 1 );
 221
 222         my @list = sort {
 223                 $a->ou_type <=> $b->ou_type ||
 224                 $a->name cmp $b->name } @$orglist;
 225
 226         for my $org (@list) {
 227
 228                 next unless ($org);
 229
 230                 if(!ref($org->ou_type()) and $add_types) {
 231                         $org->ou_type( $org_typelist_hash->{$org->ou_type()});
 232                 }
 233
 234                 next unless (defined($org->parent_ou));
 235
 236                 my ($parent) = grep { $_->id == $org->parent_ou } @list;
 237                 next unless $parent;
 238                 $parent->children([]) unless defined($parent->children);
 239                 push( @{$parent->children}, $org );
 240         }
 241
 242         return $list[0];
 243
 244 }
 245
 246
 247 sub start_long_request {
 248
 249         my($self, $service, $method, @params) = @_;
 250
 251         my $session = OpenSRF::AppSession->create( $service );
 252         my $request = $session->request( $method, @params );
 253         my $response = $request->recv(30);
 254
 255         $request->wait_complete;
 256
 257         if(!$request->complete) {
 258                 throw $response ("Call to $service for method $method with params @params" .
 259                                 "\n did not complete successfully");
 260         }
 261
 262         if(!$response) {
 263                 warn "No response from $service for method $method with params @params";
 264         }
 265
 266         if($response and UNIVERSAL::isa($response,"Error")) {
 267                 throw $response ("Call to $service for method $method with params @params" .
 268                                 "\n failed with exception: " . $response->stringify );
 269         }
 270
 271         $request->finish();
 272
 273         my $value;
 274
 275         if($response) { $value = $response->content; }
 276         else { $value = undef; }
 277
 278         return [ $session, $value ];
 279 }
 280
 281 sub long_request {
 282
 283         my($self, $session, $service, $method, @params) = @_;
 284
 285         my $request = $session->request( $method, @params );
 286         my $response = $request->recv(30);
 287
 288         $request->wait_complete;
 289
 290         if(!$request->complete) {
 291                 throw $response ("Call to $service for method $method with params @params" .
 292                                 "\n did not complete successfully");
 293         }
 294
 295         if(!$response) {
 296                 warn "No response from $service for method $method with params @params";
 297         }
 298
 299         if($response and UNIVERSAL::isa($response,"Error")) {
 300                 throw $response ("Call to $service for method $method with params @params" .
 301                                 "\n failed with exception: " . $response->stringify );
 302         }
 303
 304         $request->finish();
 305
 306         my $value;
 307
 308         if($response) { $value = $response->content; }
 309         else { $value = undef; }
 310
 311         return $value;
 312 }
 313
 314 sub finish_long_request {
 315         my($self, $session) = @_;
 316         if($session) {
 317                 $session->finish();
 318                 $session->disconnect();
 319         }
 320 }
 321
 322
 323 1;