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